rust try练习

#![feature(try_trait_v2)]
#![allow(unused)]
use std::ops::{ControlFlow, FromResidual, Try};

#[derive(Debug)]
enum MyTry {
    TOK(Vec<String>),
    TERR(Vec<String>),
}

impl FromResidual for MyTry {
    /// from的目的是复原对象
    fn from_residual(residual: <Self as Try>::Residual) -> Self {
        println!("调用 from_residual: {residual:?}");
        let mut residual = residual;
        residual.push("调用 from_residual".to_string());
        MyTry::TERR(residual)
    }
}

impl Try for MyTry {
    type Output = Vec<String>;
    type Residual = Vec<String>;

    /// from的目的是复原对象
    fn from_output(output: Self::Output) -> Self {
        println!("调用 from output: {output:?}");
        let mut output = output;
        output.push("调用 from_output".to_string());
        MyTry::TOK(output)
    }

    /// 在执行到?时, 调用branch来判断是继续还是返回
    /// 继续时, 类型为 Self::Output, 
    /// 返回时, 类型为 Self, 
    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
        match self {
            MyTry::TOK(ok) => {
                println!("branch ok");
                let mut ok= ok;
                ok.push("被分支ok修改".to_string());
                ControlFlow::Continue(ok)
            }
            MyTry::TERR(err) => {
                println!("branch err");
                let mut err = err;
                err.push("被分支err修改".to_string());

                ControlFlow::Break(err)
            }
        }
    }
}

fn try1() -> MyTry {
    let r1 = MyTry::TOK(vec!["初始化的数据".to_string()])?;
    println!("r1 is {:?}", r1);


    MyTry::TOK(r1)
}

fn try2() -> MyTry {

    let r2 = MyTry::TERR(vec!["初始化的数据".to_string()])?;
    println!("r2 is {:?}", r2);

    MyTry::TOK(r2)
}

fn main() {
    let rs = try1();
    println!("rs: {:?}", rs);

    let rs2 = try2();
    println!("rs2: {rs2:?}");
}