37

How would I idiomatically create a string to string hashmap in rust. The following works, but is it the right way to do it? is there a different kind of string I should be using?

use std::collections::hashmap::HashMap;
//use std::str;
fn main() {
        let mut mymap = HashMap::new();
        mymap.insert("foo".to_string(), "bar".to_string());
        println!("{0}", mymap["foo".to_string()]);
}
Drew LeSueur
  • 19,185
  • 29
  • 89
  • 106

2 Answers2

34

Assuming you would like the flexibility of String, HashMap<String, String> is correct. The other choice is &str, but that imposes significant restrictions on how the HashMap can be used/where it can be passed around; but if it it works, changing one or both parameter to &str will be more efficient. This choice should be dictated by what sort of ownership semantics you need, and how dynamic the strings are, see this answer and the strings guide for more.

BTW, searching a HashMap<String, ...> with a String can be expensive: if you don't already have one, it requires allocating a new String. We have a work around in the form of find_equiv, which allows you to pass a string literal (and, more generally, any &str) without allocating a new String:

use std::collections::HashMap;
fn main() {
    let mut mymap = HashMap::new();
    mymap.insert("foo".to_string(), "bar".to_string());
    println!("{}", mymap.find_equiv(&"foo"));
    println!("{}", mymap.find_equiv(&"not there"));
}

playpen (note I've left the Option in the return value, one could call .unwrap() or handle a missing key properly).

Another slightly different option (more general in some circumstances, less in others), is the std::string::as_string function, which allows viewing the data in &str as if it were a &String, without allocating (as the name suggests). It returns an object that can be dereferenced to a String, e.g.

use std::collections::HashMap;
use std::string;

fn main() {
    let mut mymap = HashMap::new();
    mymap.insert("foo".to_string(), "bar".to_string());
    println!("{}", mymap[*string::as_string("foo")]);
}

playpen

(There is a similar std::vec::as_vec.)

Community
  • 1
  • 1
huon
  • 94,605
  • 21
  • 231
  • 225
  • Could [`MaybeOwned`](http://doc.rust-lang.org/std/str/enum.MaybeOwned.html) allow some flexibility here? It seems it could be used as key? – Matthieu M. Oct 12 '14 at 17:33
  • @MatthieuM that is another approach, yeah. – huon Oct 12 '14 at 21:58
  • 6
    I take it `find_equiv()` is no longer necessary? Your Playpen example doesn't compile anymore, and I don't see a `find_equiv` method on `HashMap`. – dimo414 Dec 04 '17 at 06:00
  • 7
    `find_equiv()` has been removed in favor of the [`Borrow`](https://doc.rust-lang.org/std/borrow/trait.Borrow.html) trait. Conversion between `&str` and `&String` is done automatically now when using [`HashMap`](https://doc.rust-lang.org/std/collections/struct.HashMap.html) get/contains/remove methods. Working playpen [here](https://play.rust-lang.org/?gist=a3d3d81aa5917cad982bb8e0b5ff0ed1&version=stable&mode=debug&edition=2015). – Tey' Sep 02 '18 at 08:12
7

Writing this answer for future readers. huon's answer is correct at the time but *_equiv methods were purged some time ago.

The HashMap documentation provides an example on using String-String hashmaps, where &str can be used.

The following code will work just fine. No new String allocation necessary:

use std::collections::HashMap;

fn main() {
    let mut mymap = HashMap::new();
    mymap.insert("foo".to_string(), "bar".to_string());
    println!("{0}", mymap["foo"]);
    println!("{0}", mymap.get("foo").unwrap());
}
janreggie
  • 334
  • 1
  • 4
  • 12