// 示例代码：使用 try_match_inner 进行内联模式匹配
use try_match_inner::try_match;

fn main() {
    let value: Result<i32, &str> = Ok(42);
    
    // 使用 try_match! 宏进行模式匹配
    let result = try_match!(value, Ok(x) => x * 2);
    
    println!("Result: {:?}", result); // 输出: Result: Some(84)
    
    // 处理错误情况
    let error_value: Result<i32, &str> = Err("Something went wrong");
    let error_result = try_match!(error_value, Ok(x) => x * 2);
    
    println!("Error result: {:?}", error_result); // 输出: Error result: None
}

// 更复杂的示例：嵌套模式匹配
enum ComplexEnum {
    A(i32),
    B(String, i32),
    C { x: i32, y: i32 },
}

fn process_complex(value: ComplexEnum) -> Option<i32> {
    try_match!(value,
        ComplexEnum::A(x) => x,
        ComplexEnum::B(_, y) => y,
        ComplexEnum::C { x, y } => x + y
    )
}

// 完整示例演示
fn demonstrate_try_match() {
    // 示例1: 基本用法
    let opt = Some(10);
    let doubled = try_match!(opt, Some(x) => x * 2);
    assert_eq!(doubled, Some(20));
    
    // 示例2: 处理不同的枚举变体
    let result: Result<i32, String> = Ok(5);
    let processed = try_match!(result, Ok(x) => format!("Value: {}", x));
    assert_eq!(processed, Some("Value: 5".to_string()));
    
    // 示例3: 模式不匹配时返回 None
    let none_value: Option<i32> = None;
    let no_result = try_match!(none_value, Some(x) => x);
    assert_eq!(no_result, None);
    
    // 示例4: 使用守卫条件
    let number = Some(15);
    let filtered = try_match!(number, Some(x) if x > 10 => x);
    assert_eq!(filtered, Some(15));
    
    println!("All demonstrations passed!");
}

try_match_inner是一个Rust宏库，它扩展了Rust的模式匹配功能，提供了更灵活和安全的内联匹配表达式。该库允许你在表达式中直接使用模式匹配，而不需要完整的match语句。

主要特性：

• 内联模式匹配表达式
• 类型安全的错误处理
• 支持所有标准模式匹配功能
• 编译时错误检查

安装方法： 在Cargo.toml中添加依赖：

try_match_inner = "0.5.2"

或者运行命令：

cargo add try_match_inner

使用示例：

use try_match_inner::try_match;

// 基本用法
let value = Some(42);
let result = try_match!(value, Some(x) => x.to_string());

// 处理Result类型
let res: Result<i32, &str> = Ok(10);
let value = try_match!(res, Ok(v) => v * 2);

// 复杂模式匹配
enum Message {
    Text(String),
    Number(i32),
    Quit,
}

let msg = Message::Text("hello".to_string());
let text = try_match!(msg, Message::Text(s) => s);

该库特别适用于需要在表达式上下文中进行模式匹配的场景，提供了比标准match语句更简洁的语法，同时保持类型安全和编译时检查。

完整示例demo：

// 完整示例：展示 try_match_inner 的各种用法
use try_match_inner::try_match;

fn main() {
    // 示例1: 处理Option类型
    let some_value = Some(42);
    let none_value: Option<i32> = None;
    
    // 匹配Some值
    let result1 = try_match!(some_value, Some(x) => x * 2);
    println!("Some值处理结果: {:?}", result1); // 输出: Some(84)
    
    // 匹配None值返回None
    let result2 = try_match!(none_value, Some(x) => x);
    println!("None值处理结果: {:?}", result2); // 输出: None
    
    // 示例2: 处理Result类型
    let ok_result: Result<i32, &str> = Ok(100);
    let err_result: Result<i32, &str> = Err("错误信息");
    
    let ok_processed = try_match!(ok_result, Ok(x) => format!("成功: {}", x));
    let err_processed = try_match!(err_result, Ok(x) => format!("成功: {}", x));
    
    println!("Ok结果: {:?}", ok_processed); // 输出: Some("成功: 100")
    println!("Err结果: {:?}", err_processed); // 输出: None
    
    // 示例3: 自定义枚举匹配
    #[derive(Debug)]
    enum CustomEnum {
        First(i32),
        Second(String, bool),
        Third { id: u32, name: String },
    }
    
    let first_var = CustomEnum::First(123);
    let second_var = CustomEnum::Second("测试".to_string(), true);
    let third_var = CustomEnum::Third { id: 1, name: "名称".to_string() };
    
    let first_result = try_match!(first_var, CustomEnum::First(num) => num);
    let second_result = try_match!(second_var, CustomEnum::Second(s, b) => format!("{}: {}", s, b));
    let third_result = try_match!(third_var, CustomEnum::Third { id, name } => format!("ID: {}, Name: {}", id, name));
    
    println!("First结果: {:?}", first_result); // 输出: Some(123)
    println!("Second结果: {:?}", second_result); // 输出: Some("测试: true")
    println!("Third结果: {:?}", third_result); // 输出: Some("ID: 1, Name: 名称")
    
    // 示例4: 使用守卫条件
    let numbers = vec![Some(5), Some(15), Some(25), None];
    
    for num in numbers {
        let filtered = try_match!(num, Some(x) if x > 10 => x);
        println!("过滤结果: {:?}", filtered);
        // 输出:
        // 过滤结果: None
        // 过滤结果: Some(15)
        // 过滤结果: Some(25)
        // 过滤结果: None
    }
    
    // 示例5: 链式操作
    let complex_result: Result<Option<i32>, &str> = Ok(Some(50));
    
    let final_result = try_match!(complex_result, 
        Ok(Some(x)) if x > 0 => x * 3,
        Ok(Some(x)) => x,
        Ok(None) => 0,
        Err(_) => -1
    );
    
    println!("最终结果: {:?}", final_result); // 输出: Some(150)
    
    println!("所有示例执行完成！");
}