是否有任何内置方式可以“组合”两个选项？

Question

在下面的示例程序中，有什么方法可以避免定义map2？

fn map2<T, U, V, F: Fn(T, U) -> V>(f: F, a: Option<T>, b: Option<U>) -> Option<V> {
    match a {
        Some(x) => match b {
            Some(y) => Some(f(x, y)),
            None => None,
        },
        None => None,
    }
}

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |a, b| {
        a + b
    };
    let res = map2(f, a, b);
    println!("{:?}", res);
    // prints Some(15)
}

对于也会说 Haskell 的人，我想这个问题也可以表述为“我们可以使用任何工具来代替 Rust 中的 liftM2 吗？”

Answer 1

我不相信有一个直接函数相当于liftM2，但你可以像这样组合Option::and_then和Option::map：

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |a, b| {
        a + b
    };

    println!("{:?}", a.and_then(|a| b.map(|b| f(a, b))));
}

输出：

Some(15)

Answer 2

从 Rust 1.46.0 开始，您可以使用 Option::zip:

fn map2<T, U, V, F: Fn(T, U) -> V>(f: F, a: Option<T>, b: Option<U>) -> Option<V> {
    match a.zip(b) {
        Some((x, y)) => Some(f(x, y)),
        None => None,
    }
}

这可以和Option::map结合，如其他答案所示：

fn map2<T, U, V, F: Fn(T, U) -> V>(f: F, a: Option<T>, b: Option<U>) -> Option<V> {
    a.zip(b).map(|(x, y)| f(x, y))
}

Answer 3

我不知道你是否可以降到一行（编辑：哦，接受的答案很好地降到了一行），但你可以通过匹配一个元组来避免嵌套的 match：

let a = Some(5);
let b = Some(10);
let f = |a, b| {
    a + b
};
let res = match (a, b) {
    (Some(a), Some(b)) => Some(f(a, b)),
    _ => None,
};
println!("{:?}", res);
// prints Some(15)

Answer 4

您可以使用Options 可以迭代的事实。迭代这两个选项，将它们压缩在一起，然后将生成的迭代器映射到您的函数上。

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |(a, b)| {
        a + b
    };
    let res = a.iter().zip(b.iter()).map(f).next();
    println!("{:?}", res);
    // prints Some(15)
}

这需要修改f，因此参数被合并为一个元组参数。可以不修改f，直接映射|args| f.call(args)，但是你必须specify the closure kind of f。

Answer 5

let num_maybe = Some(5);
let num_maybe2 = Some(10);
let f = |a, b| {
    a + b
};

选项 1

if let (Some(a), Some(b)) = (num_maybe, num_maybe2) {
    f(a, b)
}

选项 2

num_maybe.and_then(|a| num_maybe2.map(|b| f(a, b))

选项 3

[num_maybe, num_maybe2].into_iter().flatten().fold(0, f)

Answer 6

您可以将immediately invoked function expression (IIFE) 与?（try）运算符结合使用：

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |a, b| a + b;

    let res = (|| Some(f(a?, b?)))();

    println!("{:?}", res);
}

以后你可以使用try blocks：

#![feature(try_blocks)]

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |a, b| a + b;

    let res: Option<_> = try { f(a?, b?) };

    println!("{:?}", res);
}

另见：

• Is there a more ergonomic syntax for Either when using futures?
• Is there a shortcut to unwrap or continue in a loop?