如何在Rust中对“选项”分配进行分组？

Question

我有一个代码块需要一次分配多个可选变量。几乎没有机会获得任何值，因此单独处理每个失败的案例并不是特别有用。

目前我写的检查是这样的：

if let Some(a) = foo_a() { 
    if let Some(b) = foo_b() { 
     if let Some(c) = foo_c() { 
      if let Some(d) = foo_d() { 
       // code 
      } 
     } 
    } 
} 

这将是方便，如果有可能小组作业。没有这一点，增加了新的变数缩进块一个水平，使得在嘈杂的比较和导致不必要的深压痕：

if let Some(a) = foo_a() && 
    let Some(b) = foo_b() && 
    let Some(c) = foo_c() && 
    let Some(d) = foo_d() 
{ 
    // code 
} 

有if语句来分配多个Option S IN一个办法？

---

一些细节值得注意：

失败应该短路，而不是叫别人第一个函数。否则，它可以被写成这样：

if let (Some(a), Some(b), Some(c), Some(d)) = (foo_a(), foo_b(), foo_c(), foo_d()) { 
    // Code 
} 

可以用一个功能避免深的压痕，但我宁愿不要这样做，因为你可能不希望拥有的身在不同的范围...

fn my_function(a: Foo, b: Foo, c: Foo, d: Foo) { 
    // code 
} 

if let Some(a) = foo_a() { 
    if let Some(b) = foo_b() { 
     if let Some(c) = foo_c() { 
      if let Some(d) = foo_d() { 
       my_function(a, b, c, d); 
      } 
     } 
    } 
} 

Answer 1

标准库不包含该确切功能，但该语言允许您使用小的宏创建所需的行为。

这就是我想出了：

macro_rules! all_or_nothing { 
    ($($opt:expr),*) => {{ 
     if false $(|| $opt.is_none())* { 
      None 
     } else { 
      Some(($($opt.unwrap(),)*)) 
     } 
    }}; 
} 

你可以给它所有的选择，并得到一些元组包含展开的值，如果所有值都Some，或None在任何的选项的情况下None。

以下是关于如何使用它的一个简单的例子：

fn main() { 
    let foo = Some(0); 
    let bar = Some(1); 
    let baz = Some(2); 
    if let Some((a, b, c)) = all_or_nothing!(foo, bar, baz) { 
     println!("foo: {}; bar: {}; baz: {}", a, b, c); 
    } else { 
     panic!("Something was `None`!"); 
    } 
} 

这里有一个完整的测试套件为宏：Rust Playground

Answer 2

老实说，应该有人通知一下Option作为一个适用函子： ）

该代码将是相当丑陋，没有在铁锈支持，但它的工作原理，它不应该有一个嘈杂的差异：

fn foo_a() -> Option<isize> { 
    println!("foo_a() invoked"); 
    Some(1) 
} 

fn foo_b() -> Option<isize> { 
    println!("foo_b() invoked"); 
    Some(2) 
} 

fn foo_c() -> Option<isize> { 
    println!("foo_c() invoked"); 
    Some(3) 
} 

let x = Some(|v| v) 
    .and_then(|k| foo_a().map(|v| move |x| k((v, x)))) 
    .and_then(|k| foo_b().map(|v| move |x| k((v, x)))) 
    .and_then(|k| foo_c().map(|v| move |x| k((v, x)))) 
    .map(|k| k(())); 

match x { 
    Some((a, (b, (c,())))) => 
     println!("matched: a = {}, b = {}, c = {}", a, b, c), 
    None => 
     println!("nothing matched"), 
} 

Answer 3

我的第一个想法是做一些类似于swizard's answer的东西，但要将其包裹在一个特征中以使链条变得更清洁。不需要额外的函数调用，它也更简单一些。

它的缺点是增加了元组的嵌套。

fn foo_a() -> Option<u8> { 
    println!("foo_a() invoked"); 
    Some(1) 
} 

fn foo_b() -> Option<u8> { 
    println!("foo_b() invoked"); 
    None 
} 

fn foo_c() -> Option<u8> { 
    println!("foo_c() invoked"); 
    Some(3) 
} 

trait Thing<T> { 
    fn thing<F, U>(self, f: F) -> Option<(T, U)> where F: FnOnce() -> Option<U>; 
} 

impl<T> Thing<T> for Option<T> { 
    fn thing<F, U>(self, f: F) -> Option<(T, U)> 
     where F: FnOnce() -> Option<U> 
    { 
     self.and_then(|a| f().map(|b| (a, b))) 
    } 
} 

fn main() { 
    let x = foo_a() 
     .thing(foo_b) 
     .thing(foo_c); 

    match x { 
     Some(((a, b), c)) => println!("matched: a = {}, b = {}, c = {}", a, b, c), 
     None => println!("nothing matched"), 
    } 
} 

Answer 4

作为@SplittyDev said，您可以创建一个宏以获得您想要的功能。这里是一个替换的基于宏的解决方案，它也保留了短路行为：

macro_rules! iflet { 
    ([$p:pat = $e:expr] $($rest:tt)*) => { 
     if let $p = $e { 
      iflet!($($rest)*); 
     } 
    }; 
    ($b:block) => { 
     $b 
    }; 
} 


fn main() { 
    iflet!([Some(a) = foo_a()] [Some(b) = foo_b()] [Some(c) = foo_c()] { 
     println!("{} {} {}", a, b, c); 
    }); 
} 

Playground