Rust 生锈怎么办'；什么是泛型FromStr对象？

Rust的

str

类有一个

parse

方法，该方法返回一个

FromStr

对象

parse

是模板化的，因此可以手动指定从

str

解析的类型，例如

“3”。parse:：（）

计算为（包含32位int

3

的

结果

对象）

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

FromStr

对象时出错：

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

这不会在第一行给出错误；相反，我得到了以下错误：

<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:12:24:13错误：无法推断有关``的足够类型信息；需要类型批注或泛型参数绑定[E0282]
：24正常（m）=>println！（“foo:{}”，m），

（这里，第24行是带有

Ok（m）

的行）

---

那么这里的

m

是什么？或者“无法推断足够的类型信息”错误实际上是因为没有类型说明符就不能调用

parse

，编译器只是在实际使用生成的

Ok

类型的第一行之前才捕捉到错误吗？

这里不清楚m是什么，因为没有足够的信息可以说。它是i32吗？u64？没有人知道，包括Rust

---

你需要做点什么来帮助弄清楚它是什么类型的。要么将其传递给需要特定类型的函数，要么对其进行注释，以便确定它应该是什么类型。

这里不清楚m是什么，因为没有足够的信息来说明。它是i32吗？u64？没有人知道，包括Rust

你需要做点什么来帮助弄清楚它是什么类型的。要么将其传递给需要特定类型的函数，要么对其进行注释，以便确定它应该是什么类型

Rust的

str

类有一个

parse

方法，该方法返回一个

FromStr

对象

停在这里，这是你的错误

parse

不返回

FromStr

对象

FromStr

是一个

特征

，如果您来自OO背景，并且无法返回抽象类型的对象，则可以将其视为抽象类

因此，

parse

返回的是某种类型的

T

实例，它必须实现

FromStr

接口

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

FromStr

对象时出错

因为从str对象中不可能有这样的通用/非特定的

FromStr

对象。必须推断（从上下文）或显式指定具体类型，并且该类型必须实现

FromStr

那么这里的

m

是什么

只有您知道它应该是什么，编译器不知道，因此抱怨它不知道该做什么：）

或者“无法推断足够的类型信息”错误实际上是因为在没有类型说明符的情况下无法调用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)
    }
}

//示例1：立即指定类型
fn main（）{
让foo=“3”。解析：：（）；
火柴
{
Ok（m）=>println！（“foo:{}，m），
Err（e）=>println！（“error！{}”，e）
}
}
//示例2：部分指定结果类型
//注意：“\u1”被推断为std:：num:：parseInteror，因为
//这就是如何为“i32”定义“FromStr:：Err”。
fn main（）{
让foo:Result=“3”。parse（）；
火柴
{
Ok（m）=>println！（“foo:{}，m），
Err（e）=>println！（“error！{}”，e）
}
}
//示例3：指定展开的结果类型
fn doit（）->结果{
让foo:i32=try！（“3.parse（））；
println！（“foo:{}”，foo）；
好（（））
}
fn main（）{
匹配doit（）
{
好的（）=>（），
Err（e）=>println！（“error！{}”，e）
}
}
//示例4：允许从函数调用推断类型
fn卡利特（f:i32）{
println！（“f:{}”，f）；
}
fn main（）{
让foo=“3”。parse（）；
火柴
{
Ok（m）=>callit（m），
Err（e）=>println！（“error！{}”，e）
}
}

Rust的

str

类有一个

parse

方法，该方法返回一个

FromStr

对象

停在这里，这是你的错误

parse

不返回

FromStr

对象

FromStr

是一个

特征

，如果您来自OO背景，并且无法返回抽象类型的对象，则可以将其视为抽象类

因此，

parse

返回的是某种类型的

T

实例，它必须实现

FromStr

接口

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

FromStr

对象时出错

因为那里可以