High-rank trait bound

where
    F: for<'a> Fn(&'a str) -> &'a str,

// ❌ 这段代码会编译失败
fn apply_wrong<F>(f: F, data: &str) -> &str
where
    F: Fn(&str) -> &str,  // 这里省略了生命周期，但实际有隐含问题
{
    f(data)
}

// 等价于：
fn apply_wrong<'b, F>(f: F, data: &'b str) -> &'b str
where
    F: Fn(&'b str) -> &'b str,  // 生命周期被固定为 'b
{
    f(data)
}

fn apply_correct<F>(f: F, data: &str) -> &str
where
    F: for<'a> Fn(&'a str) -> &'a str,  // 对于任何生命周期 'a 都有效
{
    f(data)
}

// 一个可以接受任意生命周期的函数
fn identity(x: &str) -> &str {
    x
}

// 一个只接受特定生命周期的函数（实际上也是通用的，但为了演示）
fn specific<'a>(x: &'a str) -> &'a str {
    x
}

// 使用 HRTB 的 apply
fn apply_hrtb<F>(f: F, data: &str) -> &str
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    f(data)
}

// 不使用 HRTB 的 apply（生命周期被固定）
fn apply_fixed<'b, F>(f: F, data: &'b str) -> &'b str
where
    F: Fn(&'b str) -> &'b str,
{
    f(data)
}

fn main() {
    let s = String::from("hello");

    // 两种方式都可以工作
    println!("{}", apply_hrtb(identity, &s));
    println!("{}", apply_fixed(identity, &s));

    // 但是，如果传入一个需要更灵活生命周期的闭包，区别就显现了
    let closure = |x: &str| {
        // 这里做了一些操作
        x
    };

    // ✅ HRTB 版本可以工作
    println!("{}", apply_hrtb(closure, &s));

    // ❌ 非 HRTB 版本在某些复杂场景下可能失败
    // 比如如果闭包捕获了外部变量，生命周期推断会出问题
}

fn example_capture() {
    let prefix = "Result: ";

    // 这个闭包捕获了 prefix，生命周期变得复杂
    let closure = |x: &str| -> &str {
        // 实际上这里不能返回 prefix 因为生命周期不匹配
        // 但为了演示，我们只是透传
        x
    };

    // ✅ HRTB 允许这个闭包被传递
    fn takes_hrtb<F>(f: F)
    where
        F: for<'a> Fn(&'a str) -> &'a str,
    {
        // ...
    }

    takes_hrtb(closure);
}

// 定义一个需要 HRTB 的 trait
trait Parser {
    fn parse<'a>(&self, input: &'a str) -> (&'a str, Option<&'a str>);
}

// 使用 HRTB 来要求实现者必须处理所有生命周期
fn test_parser<P>(parser: P, input: &str)
where
    P: for<'a> Fn(&'a str) -> (&'a str, Option<&'a str>),
{
    let (remaining, parsed) = parser(input);
    println!("Remaining: {}, Parsed: {:?}", remaining, parsed);
}

// 标准库中的例子：Itertools::filter_map_ok
// 它使用 HRTB 来确保闭包可以处理任何生命周期

fn example_filter_map() {
    let data: Vec<Result<&str, &str>> = vec![Ok("123"), Err("err"), Ok("456")];

    // 这个闭包需要能够处理 Ok 分支返回的任意生命周期
    let result: Vec<Result<u32, &str>> = data
        .into_iter()
        .filter_map(|x| {
            match x {
                Ok(s) => s.parse::<u32>().ok().map(Ok),
                Err(e) => Some(Err(e)),
            }
        })
        .collect();
}

// 1. 在 where 子句中
where
    F: for<'a> Fn(&'a str) -> &'a str,

// 2. 在类型中直接使用
fn apply<F: for<'a> Fn(&'a str) -> &'a str>(f: F, data: &str) -> &str {
    f(data)
}

// 3. 多个生命周期参数
where
    F: for<'a, 'b> Fn(&'a str, &'b str) -> &'a str,

// 4. 在 trait bound 中
trait MyTrait {
    fn method<'a>(&self, arg: &'a str) -> &'a str;
}

// 要求类型 T 实现了这个 trait，并且对所有生命周期都有效
fn test<T: for<'a> MyTrait>(t: T, input: &str) -> &str {
    t.method(input)
}