Types 在monad管道中使用into（）

我基本上是在管道内转换一个值，如下所示：

#[derive(PartialEq)]
enum MyType { A, B }

impl Into<MyType> for i32 {
    fn into(self) -> MyType {
        match self {
            0 => MyType::A,
            _ => MyType::B
        }
    }
}

fn main() {
    let a: Result<i32, ()> = Ok(0);
    a.map(|int| int.into())
        .and_then(|enm| if enm == MyType::A { println!("A"); });
}

这确实有效，但感觉不必要的复杂：

a.map(|int| {
    let enm: MyType = int.into();
    if enm == MyType::A { println!("A"); }
});

有更好的方法吗

我遇到的问题是，

map（）

不知道应该输出哪种类型

这不是问题所在

错误是：

<anon>:16:25: 16:63 error: mismatched types:
 expected `core::result::Result<_, ()>`,
    found `()`
(expected enum `core::result::Result`,
    found ()) [E0308]
<anon>:16         .and_then(|enm| if enm == MyType::A { println!("A"); });

因此它期望函数返回一个

结果

。它用于链接返回

结果的函数，并在遇到任何错误时返回第一个遇到的错误

如果您只是想在有
Ok（）
的情况下执行一些代码，那么应该使用
If let
或
match
：

fn main() {
    let a: Result<i32, ()> = Ok(0);
    if let Ok(MyType::A) = a.map(|int| int.into()) {
        println!("A");
    }
}

您不应该将
实现为
，而应该从

实现

，这样会自动将
实现为
impl。然后您可以调用
a.map（MyType:：from）
，一切正常：

impl From<i32> for MyType {
    fn from(i: i32) -> MyType {
        match i {
            0 => MyType::A,
            _ => MyType::B
        }
    }
}

fn main() {
    let a: Result<i32, ()> = Ok(0);
    a.map(MyType::from)
        .and_then(|enm| if enm == MyType::A { Err(()) } else { Ok(enm) } );
}

MyType的impl From{
fn from（i:i32）->MyType{
比赛一{
0=>MyType:：A，
_=>MyType:：B
}
}
}
fn main（）{
设a:Result=Ok（0）；
a、 映射（MyType:：from）
然后（|enm | if enm==MyType:：A{Err（（））}else{Ok（enm）}）；
}

---

或者，您可以调用

a.map（Into:：：Into）

，但这相当冗长。

从

/

进入

二元性是有原因的，这在

中解释了您的原始代码不起作用，因为

和_then

需要一个

结果

。

fn main() {
    let a: Result<i32, ()> = Ok(0);
    if let Ok(MyType::A) = a.map(|int| int.into()) {
        println!("A");
    }
}

A

impl From<i32> for MyType {
    fn from(i: i32) -> MyType {
        match i {
            0 => MyType::A,
            _ => MyType::B
        }
    }
}

fn main() {
    let a: Result<i32, ()> = Ok(0);
    a.map(MyType::from)
        .and_then(|enm| if enm == MyType::A { Err(()) } else { Ok(enm) } );
}