While working with serde_json for reading json documents, I wrote the following line of code to obtain the result of unwrapping the return value of serde_json::from_str
:
fn get_json_content(content_s: &str) -> Option<Value> {
let ms: String = serde_json::from_str(content_s).unwrap; // <--
match serde_json::from_str(content_s) {
Ok(some_value) => Some(some_value),
Err(_) => None
}
}
As you can see, I forgot the ()
on the end of the call to unwrap
, which resulted in the following error:
error: attempted to take value of method
unwrap
on typecore::result::Result<_, serde_json::error::Error>
let ms: String = serde_json::from_str(content_s).unwrap;
But when I looked at this a bit further, the thing that struck me as odd was:
core::result::Result<_, serde_json::error::Error>
I understand what underscore means in a match context, but to instantiate a generic? So what does this mean? I couldn't find any answers in the Rust book, or reference, or a web search.
It's a placeholder. In this context, it means that there isn't enough information for the compiler to infer a type.
You can use this in your code to make the compiler infer the type for you. For example:
pub fn main() {
let letters: Vec<_> = vec!["a", "b", "c"]; // Vec<&str>
}
This is particularly handy because in many cases you can avoid using the "turbofish operator" :
fn main() {
let bar = [1, 2, 3];
let foos = bar.iter()
.map(|x| format!("{}", x))
.collect::<Vec<String>>(); // <-- the turbofish
}
vs
fn main() {
let bar = [1, 2, 3];
let foos: Vec<_> = bar // <-- specify a type and use '_' to make the compiler
// figure the element type out
.iter()
.map(|x| format!("{}", x))
.collect(); // <-- no more turbofish
}
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.