Rust 的泛型 FromStr 对象可以做什么？

Rust's str类有一个parse方法返回一个FromStr目的。parse是模板化的，因此正在解析的类型str可以手动指定，例如"3".parse::<i32>()评估为（aResult包含）32 位 int 的对象3.

但未能指定类型本身似乎并不是一个错误。相反，我在尝试打印结果时收到错误（通用/未指定）FromStr object:

let foo = "3".parse();
match foo
{
    Ok(m) => println!("foo: {}", m),
    Err(e) => println!("error! {}", e)
}

这确实not在第一行给出错误；相反，我收到以下错误：

<anon>:24:12: 24:13 error: unable to infer enough type information about `_`; type annotations or generic parameter binding required [E0282]
<anon>:24         Ok(m) => println!("foo: {}", m),

（这里，第 24 行是带有Ok(m).)

那么什么是m这里？或者“无法推断足够的类型信息”错误实际上是由于以下事实造成的：parse实际上can't在没有类型说明符的情况下调用，编译器不会捕获错误，直到结果的第一行Ok实际使用的类型？

Rust's str类有一个parse方法返回一个FromStr object.

就在这里停下来，这是你的错误。

parse不返回FromStr目的;FromStr is a trait这可以被认为是抽象类如果您来自 OO 背景，并且无法返回具有抽象类型的对象：它是抽象的！

What parse确实返回，因此是某种类型的实例T其中必须实施FromStr界面。

但未能指定类型本身似乎并不是一个错误。相反，我在尝试打印结果时收到错误（通用/未指定）FromStr object

因为不可能有这样的通用/非特定的FromStr目的。必须（从上下文）推断出具体类型或明确阐明该类型，并且该类型必须实现FromStr.

那么什么是m here?

只有你知道它应该是什么，编译器不知道，因此抱怨它不知道该怎么做:)

或者“无法推断足够的类型信息”错误实际上是由于事实上在没有类型说明符的情况下无法调用 parse，并且编译器只是在生成结果的第一行之前才捕获错误Ok实际使用的类型？

基本上。

只是编译器直到结果的第一行才捕获错误。Ok使用更多，编译器在推断类型时会立即考虑完整的函数。从编译器的角度来看，推断类型的实际线索是立即出现还是向下 50 行出现并不重要，它只需要出现在当前函数体中即可。

从开发人员的角度来看，这可能会导致对缺乏类型的抱怨源自一个奇怪的地方；这是类型推断的缺点之一。另一方面，编译器无法知道您希望将注释放在哪里。毕竟有很多种可能性：

// Example 1: immediately specifying the type
fn main() {
    let foo = "3".parse::<i32>();
    match foo
    {
        Ok(m) => println!("foo: {}", m),
        Err(e) => println!("error! {}", e)
    }
}

// Example 2: partially specifying the result type
// Note: the "_" is deduced to be std::num::ParseIntError because
//       this is how `FromStr::Err` is defined for `i32`.
fn main() {
    let foo: Result<i32, _> = "3".parse();
    match foo
    {
        Ok(m) => println!("foo: {}", m),
        Err(e) => println!("error! {}", e)
    }
}

// Example 3: specifying the result type of unwrapping
fn doit() -> Result<(), std::num::ParseIntError> {
    let foo: i32 = try!("3".parse());
    println!("foo: {}", foo);
    Ok(())
}

fn main() {
    match doit()
    {
        Ok(_) => (),
        Err(e) => println!("error! {}", e)
    }
}

// Example 4: letting the type be inferred from a function call
fn callit(f: i32) {
    println!("f: {}", f);
}

fn main() {
    let foo = "3".parse();
    match foo
    {
        Ok(m) => callit(m),
        Err(e) => println!("error! {}", e)
    }
}