// 无参数、无返回值的函数, 无返回值等效于返回 ()
fn greet_world() {
    println!("Hello, world!");
}

// 函数只能有一个返回值类型
fn function_name(parameter1: Type1, parameter2: Type2) -> ReturnType {
    // ...
}

// 接受一个参数、无返回值的函数，等效于返回 -> ()
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

// 接受两个参数、有返回值的函数
fn add(a: i32, b: i32) -> i32 {
    // 表达式的值作为函数的返回值
    a + b
}

fn main() {
    // 函数定义的顺序是无关的，可以先使用，再定义
    fizzbuzz_to(100);
}

fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
    if rhs == 0 {
        return false;
    }
    // 返回表达式值
    lhs % rhs == 0
}

fn fizzbuzz(n: u32) -> () {
    if is_divisible_by(n, 15) {
        println!("fizzbuzz");
    } else if is_divisible_by(n, 3) {
        println!("fizz");
    } else if is_divisible_by(n, 5) {
        println!("buzz");
    } else {
        println!("{}", n);
    }
}

fn main() {
    test();

    fn test() {
        println!("just fortest");
    }
}

/*
FunctionParam :
   OuterAttribute* ( FunctionParamPattern | ... | Type)

FunctionParamPattern :
  PatternNoTopAlt : ( Type | ... )
 */

fn first((value, _): (i32, i32)) -> i32 { value }

// 例子：
let my_key_fn: fn(&City) -> i64 = // 变量类型为函数指针
if user.prefs.by_population {
    city_population_descending // 函数名实际为函数指针
} else {
    city_monster_attack_risk_descending
};
cities.sort_by_key(my_key_fn);

// 另一个例子：
// 声明 fn 函数指针类型别名
type Binop = fn(i32, i32) -> i32;

//  下面这些函数签名均和 Binop 一致，故均是 Binop 类型
fn add(a: i32, b: i32) -> i32 { a + b }
fn subtract(a: i32, b: i32) -> i32 { a - b }
fn multiply(a: i32, b: i32) -> i32 { a * b }

// 使用函数指针类型作为参数类型
fn apply_operation(operation: Binop, x: i32, y: i32) -> i32 {
    // 调用函数指针对应的函数
    operation(x, y)
}

fn main() {
    // 保存函数指针类型的变量
    let mut operation_to_perform: Binop;

    operation_to_perform = add;
    println!("Result of add: {}", apply_operation(operation_to_perform, 10, 5));

    operation_to_perform = subtract;
    println!("Result of subtract: {}", apply_operation(operation_to_perform, 10, 5));

    println!("Directly passing multiply: {}", apply_operation(multiply, 10, 5));
}

fn process_data(processor: fn(i32) -> i32) {
    println("{}", processor(42));
}

fn main() {
    // OK：闭包没有捕获上下文对象
    process_data(|x| x+1);

    // ERROR：捕获了上下文对象的闭包不能转换为 fn 函数指针
    let multiplier = 2;
    process_data(|x| x*multiplier);
}

// 闭包类型参数也可以传入 fn 函数指针
let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();

fn len(
    #[cfg(windows)] slice: &[u16],
    #[cfg(not(windows))] slice: &[u8],
) -> usize {
    slice.len()
}

Function :
   FunctionQualifiers fn IDENTIFIER GenericParams? ( FunctionParameters? ) FunctionReturnType? WhereClause? ( BlockExpression | ; )

FunctionQualifiers :
   const? async? unsafe? (extern Abi?)?

Abi :
   STRING_LITERAL | RAW_STRING_LITERAL

FunctionParameters :
      SelfParam ,? | (SelfParam ,)? FunctionParam (, FunctionParam)* ,?

SelfParam :
   OuterAttribute* ( ShorthandSelf | TypedSelf )

ShorthandSelf :
   (& | & Lifetime)? mut? self

TypedSelf :
   mut? self : Type

FunctionParam :
   OuterAttribute* ( FunctionParamPattern | ... | Type2 )

FunctionParamPattern :
   PatternNoTopAlt : ( Type | ... )

FunctionReturnType :
   -> Type

fn foo() {}
// 等效于
extern "Rust" fn foo() {}

extern fn new_i32() -> i32 { 0 }
let fptr: extern fn() -> i32 = new_i32;
// 等效于
extern "C" fn new_i32() -> i32 { 0 }
let fptr: extern "C" fn() -> i32 = new_i32;

#[no_mangle]
extern "C" fn new_i32() -> i32 { 0 }

// extern block 声明
extern "C" {
  fn foo(); // 没有函数体，一般是 FFI 调用外部库的实现。
}

// 需要在 unsafe 中使用 extern block 中生命的对象
unsafe { foo() }

pub fn into_vec<A>(self: Box<[T], A>) -> Vec<T, A> where A: Allocator

let s: Box<[i32]> = Box::new([10, 40, 30]);
let x = s.into_vec();
// s 已经被 move，不能再访问。

// 'middle is used in both a co- and contravariant position.
fn takes_fn_ptr<'short, 'middle: 'short>(f: fn(&'middle ()) -> &'middle (), ) {

    // As the variance at these positions is computed separately, we can freely shrink 'middle in
    // the covariant position and extend it in the contravariant position.

    // 函数输入参数是逆变，返回结果是协变。
    let _: fn(&'static ()) -> &'short () = f;
}

let array: Rc<Box<[T; 3]>> = ...;

// val[i] 自动解引用 index() 方法的返回值，等效为 *array.index(0)
let first_entry = array[0];

// fn 函数：必须指定输入、输出参数类型
fn  add_one_v1 (x: u32) -> u32 { x + 1 }

// 闭包：输入、输出参数类型可以自动推导。
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1  ;

// 闭包：返回值类型根据后续对 one 的使用方式来定。
let one = || 1;

// block 中 return 或最后一个表达式值作为返回
let closure_annotated = |i: i32| -> i32 { i + outer_var };

// error：指定返回值类型时必须使用大括号
let is_even = |x: u64| -> bool x % 2 == 0;
// ok
let is_even = |x: u64| -> bool { x % 2 == 0 };

// 单行表达式的结果作为值返回，不需要指定大括号
let closure_inferred  = |i | i + outer_var;

let color = String::from("green");
// 闭包对应的匿名对象内部共享借用了 color（定义闭包时，借用已经发生）
let print = || println!("`color`: {}", color);
// 使用 move，闭包将 color 捕获到生成的匿名对象内部（定义闭包时，转移已经发生）
let print = move || println!("`color`: {}", color);

// 闭包的输入、输出值类型一旦被推导出来后，就不能再变化。
//
// 两次函数调用的推导类型不一致，编译失败。
let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);

// 传给闭包的参数列表也是 pattern 赋值语法。
// 如果闭包不使用传入的参数，可以将其设置为 _。
fn main() {
    foobar(32, 64, |_, _| panic!("Comparing is futile!"));
}

// 闭包捕获了函数参数 stat，它位于函数栈上，这里是共享借用 &T 捕获的方式
fn sort_by_statistic(cities: &mut Vec<City>, stat: Statistic) {
    cities.sort_by_key(|city| -city.get_statistic(stat));
}

let s = String::from("coolshell");

// s 作为闭包返回值，所以是 Move 语义。
// 在定义闭包时，s 已经被 move 捕获到闭包中，外部不能再访问。
let take_str = || s;

// s 已经被 move 进闭包，不能再访问。（除非该闭包后续不再使用）
//println!("{}", s);
println!("{}",  take_str()); // OK

let movable = Box::new(3);
let consume = || {
    println!("`movable`: {:?}", movable);
    // drop() 方法需要拥有对象所有权，所以 movable 对象被转移到闭包中
    std::mem::drop(movable);
};
consume(); // 该闭包只能调用一次
// consume(); // 报错

// 在定义闭包时捕获环境中对象，但如果闭包后续不再使用，则捕获失效，原对象可以继续访问。
let mut count = 0;
let mut inc = || {
    count += 1;  // &mut 捕获 count 对象
    println!("`count`: {}", count);
};

// 错误：count 已经被闭包 &mut 捕获，所以不能再访问和修改。
// count += 2;
inc();
// OK：闭包后续不再使用，故还可以继续访问 count。
assert_eq!(count, 1);


let color = String::from("green");
// print 有效时（后续还有调用）会保有 color 的共享引用
let print = || println!("`color`: {}", color);
print();
// 由于闭包是共享引用，所以原对象还可以有其它共享引用
let _reborrow = &color;
print();
// print 后续不再使用，所以可以 move color
let _color_moved = color;

use std::thread;

let people = vec![
    "Alice".to_string(),
    "Bob".to_string(),
    "Carol".to_string(),
];

let mut threads = Vec::new();

for person in &people {
    threads.push(thread::spawn(move || {
        // person 是 &String 类型，所以 move 捕获的是 &String 而非 String
        println!("Hello, {}!", person);
    }));
}

for thread in threads {
    thread.join().unwrap();
}

// 报错：
/*
error[E0597]: `people` does not live long enough
  --> src/main.rs:12:20
   |
12 |     for person in &people {
   |                    ^^^^^^ borrowed value does not live long enough
...
21 | }
   | - borrowed value only lives until here
   |
   = note: borrowed value must be valid for the static lifetime...
*/

// https://rust-lang.github.io/rfcs/3216-closure-lifetime-binder.html
use std::cell::Cell;

fn main() {
    let static_cell: Cell<&'static u8> = Cell::new(&25);
    let closure = |s| {};
    closure(static_cell);
    let val = 30;
    let short_cell: Cell<&u8> = Cell::new(&val);
    closure(short_cell);
}
/*
error[E0597]: `val` does not live long enough
  --> src/main.rs:8:43
   |
4  |     let static_cell: Cell<&'static u8> = Cell::new(&25);
   |                      ----------------- type annotation requires that `val` is borrowed for `'static`
...
8  |     let short_cell: Cell<&u8> = Cell::new(&val);
   |                                           ^^^^ borrowed value does not live long enough
9  |     closure(short_cell);
10 | }
   | - `val` dropped here while still borrowed
*/

let y = 10;
let add_y = |x| x + y; // add_y 闭包对象实现了 Copy
let copy_of_add_y = add_y; // Copy 赋值
assert_eq!(add_y(copy_of_add_y(22)), 42); // 调用多次


let mut x = 0;
let mut add_to_x = |n| { x += n; x }; // add_to_x 内部使用了 &mut 借用捕获 x，所以没有实现 Copy 和 Clone
let copy_of_add_to_x = add_to_x; // 复制时转移了所有权
assert_eq!(add_to_x(copy_of_add_to_x(1)), 2); // 再使用 add_to_x 时报错


let mut greeting = String::from("Hello, ");
let greet = move |name| {
    greeting.push_str(name); // move 捕获了 greeting 所有权，而 String 实现了 Clone，所以闭包实现了 Clone
    println!("{}", greeting);
};
greet.clone()("Alfred");  // OK
greet.clone()("Bruce");   // OK

// Rust 为闭包实现的 FnOnce trait 定义：
pub trait FnOnce<Args> where Args: Tuple,
{
    type Output; // 为闭包的返回值类型

    // Required method
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

// F 是 FnOnce() 类型，所以只能被调用一次；
fn f<F: FnOnce() -> String> (g: F) {
    println!("{}", g());
}

let mut s = String::from("foo");
let t = String::from("bar");
// 闭包修改和返回了 s，所以该闭包转移了 s 的所有权，编译器为其实现了 FnOnce trait, 满足函数 f 的参数限界要求
f(|| { s += &t; s});
// Prints "foobar".

// 由于闭包通过 &T 借用捕获了上下文对象，所以生成的匿名类型包含 lifetime。
struct Closure<'a> {
    s : String,     // 转移 s 所有权，不是借用：因为闭包返回 s，所以需要转移 s 所有权。
    t : &'a String, // 对于 t 是共享借用
}

// 由于闭包返回 s 即转移了捕获对象的所有权，所以闭包只能调用一次，编译器为其实现 FnOnce trait：
impl<'a> FnOnce<()> for Closure<'a> {
    type Output = String; // 闭包的返回值类型

    fn call_once(self) -> String {
        self.s += &*self.t;
        self.s
    }
}

f(|| { s += &t; s});
// 等效于：
// 定义闭包时编译器将其转换成匿名类型对象，同时将 s 的所有权转移到该对象中。
// 所以，即使没有调用闭包，s 在外界已不可访问。类似的还有通过 &T 或 &mut T 借用捕获的对象。
let c = Closure{s: s, t: &t} // Closure 的 lifetime 和 t 一致。
f(c);

// 编译器为 impl Sized 生成的匿名类型同时捕获了 ‘a 和 T
fn foo<'a, T>(x: &'a T) -> impl Sized {
    (x,)
}

// 另一个例子：
async fn foo(x: &mut i32) -> i32
// 等价于：注意返回的匿名对象包含 lifetime，和 x 一致
fn foo<'a>(x: &'a mut i32) -> impl Future<Output = i32> + 'a
// 更精确的，返回值的类型是：impl Future<Output = i32> + '_
// 这里的 '_ 表示 编译器会为其捕获函数的范型参数和 lifetime，具体参考前面的 impl Trait 一节。
//
// 后续调用 foo 返回的 fut 类型为：impl Future<Output = i32> + '_，推倒的生命周期和 v 一致。
let fut = foo(&mut v);
// 错误：fut 不是 'static 类型。
tokio::spawn(fut).await.unwrap();

// 闭包前加 move，无条件转移所引用的对象所有权到闭包中
use std::thread;
fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {:?}", list);
    // list 所有权被转移到闭包
    thread::spawn(move ||
        println!("From thread: {:?}", list)
    ).join().unwrap();
}

let color = String::from("green");
let print = move || println!("`color`: {}", color);
print();
// 报错：color 已被转移到闭包，不能再访问。
// let _reborrow = &color;
// println!("{}", _reborrow);

// Error
fn main() {
    let movable = Box::new(3);

    // consume 只能调用一次，因为它内部将 movable 变量 move 走了。
    let consume = || {
        println!("`movable`: {:?}", movable);
        take(movable);
    };
    consume();

    // 错误：闭包捕获的 movable 所有权被转移到 take() 函数，所以闭包只能调用一次。
    // consume();
}
fn take<T>(_v: T) {}

fn main() {
    let mut a = 123;
    let ar = &a;
    // a = 456; // Error：cannot assign to `a` because it is borrowed
    println!("{ar}")
}

fn main() {
    let mut x = 4;
    // x 被共享借用
    let add_to_x = |y| y + x;

    let result = add_to_x(3);
    // 输出：The result is 7
    println!("The result is {}", result);

    // 错误：在被共享借用的有效情况下(后续会调用执行该闭包), 不能修改其值
    // x = x + 3;

    let result2 = add_to_x(3);
    println!("The result2 is {}", result2);
}

// TypePathSegment 典型的情况是 :: 分割的标识符，如 ::std::ops::Index，但也支持更复杂的情况
TypePathSegment :
  PathIdentSegment (::? (GenericArgs | TypePathFn))?

PathIdentSegment → // IDENTIFIER 为函数类型关键字如 Fn/FnMut/FnOnce 等
    IDENTIFIER | super | self | Self | crate | $crate

// 函数闭包限界，如 fn myfunc(F: Fn(i32, &str) -> bool) {}
// 或 fn myfunc(S, F: Fn(i32, <S as Trait>::Assoc) -> bool)
TypePathFn :
( TypePathFnInputs? ) (-> Type)?

// 例如 std::thread::spawn() 函数的参数参数是一个闭包限界类型
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T + Send + 'static, // F 是一个 FnOnce 类型的闭包，整体实现了 Send，具有 'static 生命周期
    T: Send + 'static, // 闭包的返回值同样需要实现 Send 和 具有 'static 生命周期


fn foobar<F>(mut f: F)
    where F: FnMut(i32) -> i32
{
    let tmp = f(2);
    println!("{}", f(tmp));
}

fn main() {
    let mut acc = 2;

    // 传入的闭包实现了 FnMut trait，因为它修改了上下文对象 acc。
    foobar(|x| {
        acc += 1;
        x * acc
    });
}
// output: 24


fn foobar<F>(f: F) // 可以对 f 调用多次，因为 F 不含上下文对象的 &mut 借用，也没有转移上下文对象
    where F: Fn(i32) -> i32
{
    println!("{}", f(f(2)));
}

fn main() {
    let mut acc = 2;

    // 错误：闭包修改了 acc，所以该闭包是 FnMut 类型，不满足函数限界的 Fn 类型要求
    foobar(|x| {
        acc += 1;
        x * acc
    });
}


fn foobar<F>(f: F) // f 是 FnOnce 类型，所以可以传入 Fn/FnMut/FnOnce 类似的闭包
    where F: FnOnce() -> String
{
    println!("{}", f());
    // 错误：f 是 FnOnce 类型，所以只能被调用一次。
    // println!("{}", f());
}

// std::ops::FnOnce
pub trait FnOnce<Args> where Args: Tuple,
 {
     type Output; // 输出参数类型

     // Required method
     // 传入 self
     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
 }

// std::ops::FnMut，FnMut 是 FnOnce 子类型
pub trait FnMut<Args>: FnOnce<Args> where Args: Tuple,
 {
     // Required method
     // 传入 &mut self
     extern "rust-call" fn call_mut( &mut self, args: Args ) -> Self::Output;
 }

// std::ops::Fn, Fn 是 FnMut 子类型
pub trait Fn<Args>: FnMut<Args> where Args: Tuple,
  {
      // Required method
      // 传入 &self
      extern "rust-call" fn call(&self, args: Args) -> Self::Output;
  }

// F 是 Fn() 类型闭包
fn apply<F>(f: F) where F: Fn() {
    f();
}

fn main() {
    let x = 7;
    let print = || println!("{}", x);
    apply(print);
}


#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];
    // OK：编译器推断该闭包符合 FnMut 要求，虽然它没有捕获外围任何对象
    list.sort_by_key(|r| r.width);
    println!("{:#?}", list);
}

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];
    let mut sort_operations = vec![];
    let value = String::from("by key called");
    // 错误：编译器推断该闭包为 FnOnce 类型，不符合 sort_by_key() 的要求 FnMut
    list.sort_by_key(|r| {
        // 转移了捕获对象 value 的所有权，所以该闭包实现的是 FnOnce
        sort_operations.push(value);
        r.width
    });
    println!("{:#?}", list);
}

fn countdown<F>(count: usize, tick: F)
    where F: Fn(usize)
{
    for i in (1..=count).rev() {
        tick(i);
    }
}

fn main() {
    countdown(3, |i| println!("tick {}...", i));
    countdown(3, |_| ());
}

// 闭包是一种匿名类型，可以赋值被变量
let add = |x, y| x + y;
// 调用闭包函数
let mut x = add(5,7);

// 没有捕获环境中值的闭包，可以转换为函数指针
type Binop = fn(i32, i32) -> i32;
let bo: Binop = add;
x = bo(5,7);

// 闭包限界不一定一定要使用 HRTB lifetime，也可以使用特定的 lifetime 标记:
fn apply_fnmut_simple<'a, 'b, F>(
    mut f: F,
    x: &'a i32,
    y: &'b str,
) -> Combined<'a, 'b>
where
    // FnMut 限界没有使用 HRTB，而是特定的 'a 和 'b, 故在调用时只能传入和参数 x、y 相同 lifetime 借用参数
    F: FnMut(&'a i32, &'b str) -> Combined<'a, 'b>,
{
    f(x, y)
}

// FnMut 限界使用了 HRTB，在调用时可以传入任意 lifetime 的借用参数
fn apply_fnmut_simple2<'a, 'b, F>(
    mut f: F,
    x: &'a i32,
    y: &'b str,
) -> Combined<'a, 'b>
where
    F: for<'x, 'y> FnMut(&'x i32, &'y str) -> Combined<'x, 'y>,
{
    f(x, y) // x 和 y 的 lifetime 都是 HRTB lifetime 的子类型，所以可以赋值。
}

fn call_on_ref_zero<F>(f: F) where for<'a> F: Fn(&'a i32) {
    let zero = 0;
    // f 的 'a 是 HRTB，所以任意短，所以 &zero 的生命周期比它长，可以传给 f 闭包。
    f(&zero);
}

struct Closure<F> {
    data: (u8, u16),
    func: F,
}

// 1. 函数 Closure 泛型参数中没有 'a lifetitme
//
// 2. 在 F 的 Bound 中使用 for <'a> 来声明 'a lifetime，这里 for <'a> 表示对于任意 lifetime 'a, Fn 都满足， 也即 for <'a> 的
// 'a 可以看作无限短，其它任何具体的 lifetime 都是它的 subtype
impl<F> Closure<F> where F: for <'a> Fn(&'a (u8, u16)) -> &'a u8,
{
    fn call<'a>(&'a self) -> &'a u8 {
        // 'a 和上面的 for <'a> 没有关系，是 call() 方法自己的 lifetime。
        // 由于编译器会自动加 lifetime，所以可以不指定 'a 如：fn call(&self) -> &u8
        (self.func)(&self.data)
    }
}

fn do_it<'b>(data: &'b (u8, u16)) -> &'b u8 { &data.0 }

fn main() {
    'x: {
        let clo = Closure {
            data: (0, 1),
            // 由于 F 是 HRTB，任意其它 lifetime（如 'b) 都是它的子类型，可以赋值给 func。
            func: do_it
        };
        println!("{}", clo.call());
    }
}

impl<T> [T] {
    pub fn sort_by_key<K, F>(&mut self, mut f: F)
    where
        // F 是 FnMut 类型，由于输入包含借用 &T 但没有声明 liftime，编译器自动转换为 HRTB 声明，
        // 等效为： F: for<'a> FnMut<&'a T> -> K,
        F: FnMut(&T) -> K,
        K: Ord,
    {
        stable_sort(self, |a, b| f(a).lt(&f(b)));
    }
}

// 另一例子：使用 HRTB，这里由于输入、输出包含多个借用，则必须显式指定它的 lifetime（如果输入、输出只包含一个引用，则由于
// lifetime-elision，可以忽略 lifetime）
fn apply_fnmut_simple2<'a, 'b, F>(
    mut f: F,
    x: &'a i32,
    y: &'b str,
) -> Combined<'a, 'b>
where
    F: for<'x, 'y> FnMut(&'x i32, &'y str) -> Combined<'x, 'y>,
{
    f(x, y)
}

#[derive(Debug)]
struct Combined2<'a> {
    num: &'a i32
}

fn apply_fn_mut_simple4<'a, 'b, F>(
    mut f: F,
    x: &'a i32,
    _y: &'b str,
) -> Combined2<'a>
where
    // 这里应该是使用了 HRTB，同时使用 lifetime-elision 将输出和输入的借用关联起来。
    // 等效为：F: for<'x> FnMut(&'x i32) -> Combined2<'x>
    F:  FnMut(&i32) -> Combined2,
{
    f(x)
}

fn main(){
    let x = 23;
    let y = "sfasd";
    let result = apply_fn_mut_simple4(|i| Combined2{num: i}, &x, &y);
    println!("{result:?}");
}

type BoxedCallback = Box<dyn Fn(&i32) -> i32>;
struct BasicRouter{
    routers: std::collections::HashMap<String, Boxe dCallback>
}

//
impl BasicRouter {
    fn add_route<C>(&mut self, url: &str, callback: C)
        where C: Fn(&i32) -> i32 // 因为 Box<T> 等价于 Box<T + 'static >，所以这里必须添加 + 'static 约束
      {
          self.routers.insert(url.to_string(), Box::new(callback));
      }
}
/*
error[E0310]: the parameter type `C` may not live long enough
   --> src/main.rs:182:46
    |
182 |         self.routers.insert(url.to_string(), Box::new(callback));
    |                                              ^^^^^^^^^^^^^^^^^^
    |                                              |
    |                                              the parameter type `C` must be valid for the static lifetime...
    |                                              ...so that the type `C` will meet its required lifetime bounds
    |
help: consider adding an explicit lifetime bound
    |
180 |         C: Fn(&i32) -> i32 + 'static, // 要求闭包是 'static 的，即闭包的参数和捕获的借用都必须是 'static
    |                            +++++++++
*/

// 解决办法：
impl BasicRouter {
    // 要求闭包是 'static 的，即闭包返回借用类型值、捕获的借用都必须是 'static，否则将所有权转移到 Box 中是不安全的
    fn add_route<C>(&mut self, url: &str, callback: C) where C: Fn(&i32) -> i32  + 'static
      {
          self.routers.insert(url.to_string(), Box::new(callback));
      }
}

async fn for_each_city<F, Fut>(mut f: F)
where
    // 错误：不支持 HRTB, 所以这里 Rust 为包含引用的限界自动添加的 HRTB 无效：F: for<'c> FnMut(&'c str) -> Fut,
    F: FnMut(&str) -> Fut,
    Fut: Future<Output = ()>,
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

async fn do_something2(city_name: &str) { todo!() }

async fn main() {
    for_each_city(do_something2).await;
}

/*
error[E0308]: mismatched types
   --> src/main.rs:101:5
    |
101 |     for_each_city(do_something2).await;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
    |
    = note: expected opaque type `impl for<'c> Future<Output = ()>`  // 期望的是一个 HRTB 的高阶 lifetime
               found opaque type `impl Future<Output = ()>` // 实际是编译器自动创建的一个具有特定 lifetime 的匿名类型
    = note: distinct uses of `impl Trait` result in different opaque types
*/

async fn for_each_city<F>(mut f: F)
where
    F: AsyncFnMut(&str) -> (),
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

async fn do_something2(city_name: &str) { todo!() }

async fn main() {
    for_each_city(do_something2).await;
}

// 错误：同步闭包不支持 HRTB
// 返回的 Combined 也是有 lifetime 的，但是它的 lifetime 和 a、b 之间约束缺少定义，所以编译器报错。
// 如果只是纯输入有借用，但是输出没有借用（或为 'static) 且闭包内部没有借用方式捕获上下文，则是 OK 的。
let mut closure = |a: &i32, b: &str|  {Combined { num: a, text: b }}

pub trait FnOnce<Args> where Args: Tuple,
{
    type Output; // 为闭包的返回值类型

    // Required method
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

pub trait FnMut<Args>: FnOnce<Args> where Args: Tuple,
{
    // Required method
    extern "rust-call" fn call_mut(&mut self, args: Args,) -> Self::Output;
}

pub trait Fn<Args>: FnMut<Args> where  Args: Tuple,
{
    // Required method
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

let mut fields: Vec<&str> = Vec::new();
let pusher = |a: &str| {
    fields.push(a);
};

/*
error[E0521]: borrowed data escapes outside of closure
   --> src/main.rs:110:9
    |
108 |     let mut fields: Vec<&str> = Vec::new();
    |         ---------- `fields` declared here, outside of the closure body
109 |     let pusher = |a: &str| {
    |                   - `a` is a reference that is only valid in the closure body
110 |         fields.push(a);
    |         ^^^^^^^^^^^^^^ `a` escapes the closure body here
    |
    = note: requirement occurs because of a mutable reference to `Vec<&str>`
    = note: mutable references are invariant over their type parameter
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
*/

// ‘a 为捕获的上下文对象借用 fields 的生命周期
struct Closure<'a> {
    fields: &'a mut Vec<&'a str>, // 捕获的变量（推断出的借用方式）
}

// 闭包的实现：
// 'a 为捕获的上下文对象借用 fields 的生命周期
// 'b 为传入的对象 str 的生命周期
impl<'a, 'b> FnMut<(&'b str,)> for Closure<'a> {
    type Output = ()

    extern "rust-call" fn call_mut(&mut self, (a,): (&'b str,)) -> () {
        self.fields.push(a);
    }
}

let mut fields: Vec<&str> = Vec::new();
let pusher = |a: &str| {fields.push(a); a};

// 报错：
/*
error: lifetime may not live long enough
   --> src/main.rs:111:9
    |
109 |     let pusher = |a: &str| {
    |                      -   - return type of closure is &'2 str
    |                      |
    |                      let's call the lifetime of this reference `'1`
110 |         fields.push(a);
111 |         a
    |         ^ returning this value requires that `'1` must outlive `'2`
*/

// 类似的例子：
fn fn_elision(x: &i32) -> &i32 { x } // 函数 OK，`lifetime-elision` 会自动将输出的 lifetime 设置为和输入一致

// 编译器将闭包函数 lifetime 标记为（注意：闭包函数不适用于普通函数的 lifetime elision 规则）：|x: &'a i32| -> &'b i32 { x }
// 这里要求 'a: 'b, 但是这个关系并没有明确定义，所以拒绝编译；
let closure_elision = |x: &i32| -> &i32 { x };
// |     let closure = |x: &i32| -> &i32 { x };
// |                       -        -      ^ returning this value requires that `'1` must outlive `'2`
// |                       |        |
// |                       |        let's call the lifetime of this reference `'2`
// |                       let's call the lifetime of this reference `'1`