此软件包提供了 tri! 宏，一个用于简洁编写繁琐的 try-except 语句的工具。

从函数中解包选项或结果是一个常见任务。虽然 ? 运算符可能很有用，但它转发异常而不是处理它们。

[dependencies]
tri_ton = "0.0.2"

use tri_ton::tri;

// Try Formats
tri!(a => b $$ c);
tri!(a => b(A) $$ c);
tri!(a => b[B] $$ c);
tri!(a => [R] $$ c);

• $$ - 三重运算符
• a - 要评估的表达式
• b - a 的预期输出
• c - 替代表达式。
• A - 枚举变体的字段 b
• B - 枚举变体 b 的字段
• R - 与 a 的输出比较的模式-规则

a 可以是 Rust 语言的任何形式的表达式。例如，foo()、foo::BAR 和 5_usize 都是可接受的表达式。

b 可以是大多数枚举变体和路径。例如，None 和 crate::foo::<bar>::cin 都是可接受的路由。

c 可以是单个或多个替代表达式。当 a 的输出或值不匹配 b 时，通常会以某种形式评估这些表达式。

A 可以是变量声明或空模式。如果枚举变体有多个字段，则可以指定多个以逗号分隔的项目。例如，foo、ref mut bar 和 _ 都是可接受的项目。

在表达式tri!(foo => Some(bar) $$ ...)中，bar 将像函数输出一样返回。在表达式 let cin = tri!(foo => Some(bar) $$ ...) 中，值 bar 将绑定到变量 cin。

B 与 A 类似。然而，像 B 这样声明的变量会在局部作用域内自动绑定。在表达式 tri!(foo => bar[cin] $$ ...) 中，变量 cin 会自动绑定到与 tri 宏相同的作用域。

R 用于将非枚举值与模式匹配。 ..foo、_ 和 (FOO, 0..=bar) 都是可接受的模式。

三表达式

tri! 有五个操作符用于处理异常。

• 三-降级
• 三-失败
• 三-返回
• 三-直到
• 三-当

三-降级

<> 操作符可以用来提供一个回退值，如果表达式不匹配给定的项。

use tri_ton::tri;

fn main() {
   let foo = Some(true);
   
   // If `foo` is Some(bar), `cin` is initialized with `bar`.
   // If `foo` isn't Some,  `cin` is initialized as false.
   let cin = tri!(foo => Some(bar) <> false);
}

三-失败

-> 操作符在表达式不匹配给定项时返回尾部表达式。

use tri_ton::tri;

fn foo_bar() -> Result<bool, &'static str> {
   let foo = Some(true);
   
   // If `foo` isn't Some, Err("Error!") is automatically returned.
   tri!(foo => Some[bar] -> "Error!");
   
   // `bar` is now an accessible variable.
   Ok(bar)
}

三-返回

#> 操作符返回尾部表达式而不包含错误包装器。它也可以用作一个中断表达式。

#[no_std]
use tri_ton::tri;

fn foo_loop() -> Result<(), &'static str> {
   let foo = Some(true);
   
   // If `foo` isn't Some, Err("Custom Error!") gets returned.
   tri!(foo => Some[bar] #> Err("Custom Error!"));
   
   'a: loop {
       // If `bar` isn't false, the loop will be broken.
       tri!(bar => [false] #> break 'a);
   }
}

三-直到

%> 操作符会重复评估前面的表达式，直到它匹配给定的项。对于每次表达式不匹配给定的项，都会评估尾部表达式。

use tri_ton::tri;

fn main() {
     let mut foo: u8 = 0;
    
    // Until `foo` equals 10, the loop will increment `foo`.
     tri!(foo => [10] %> foo += 1);
}

三-当

>> 操作符类似于一个 do-while 循环。尾部表达式会使用一组初始值进行评估。然后，前面的表达式会在循环中进行评估，并且对于每次它匹配给定的项，尾部表达式会使用这些值进行评估。

use tri_ton::tri;

fn main() { 
    let foo = |a: u8| -> Option<u8> {
        if a >= 10 { None }
        else { Some(a) }
    };
    
    // This is performed until foo(bar) returns None.
    tri!(foo(bar) => Some[mut bar = 0] >> bar += 1);
    assert_eq!(bar, 10);
    
    // "bar += 1" is performed before "foo(bar)" is checked.
    tri!(foo(bar) => Some[mut bar = bar] >> bar += 1);
    assert_eq!(bar, 11);
}