tiny_fn! 宏支持一次性定义多个项目。

tiny_fn! {
    struct Foo = Fn(a: i32, b: i32) -> i32;
    struct Bar = Fn() -> String;
}

let foo: Foo = Foo::new(|a, b| a + b);
let bar: Bar = Bar::new(|| "Hello, World!".to_string());

assert_eq!(foo.call(1, 2), 3);
assert_eq!(bar.call(), "Hello, World!");

可见性

tiny_fn! 宏支持可见性限定符。

tiny_fn! {
    pub struct Foo = Fn(a: i32, b: i32) -> i32;
    struct Bar = Fn() -> String;
    pub(crate) struct Baz = Fn();
}

属性

tiny_fn! 宏支持项目属性，包括文档。

tiny_fn! {
    /// This is `Foo` wrapper for that takes two `i32`s and return `i32`.
    pub struct Foo = Fn(a: i32, b: i32) -> i32;
}

Fn* 特性族

tiny_fn! 宏可以为 Fn* 特性族中的任何特性生成闭包包装器。

tiny_fn! {
    struct A = Fn();
    struct B = FnMut();
    struct C = FnOnce();
}

let a = 42;
let a: A = A::new(|| println!("{}", a));
a.call();
a.call();

let mut b = 42;
let mut b: B = B::new(|| b += 1);
b.call();
b.call();

let c = String::from("Hello, World!");
let c: C = C::new(move || println!("{}", c));
c.call();
// c.call(); // This will not compile, because `C` can be called only once.

• A 只能包装在不可变借用时可以调用的闭包。因此，A::call 接受 &self。
• B 只能包装在借用时可以调用的闭包。因此，B::call 接受 &mut self。
• C 可以包装任何闭包，甚至是一次性可调用的闭包。因此，C::call 接受 self。

泛型

闭包包装器可以声明为泛型，这些类型应该在函数签名中使用。

tiny_fn! {
    struct BinOp<T> = Fn(a: T, b: T) -> T;
}

let add: BinOp<i32> = BinOp::new(|a, b| a + b);
let mul: BinOp<i32> = BinOp::new(|a, b| a * b);

assert_eq!(mul.call(add.call(1, 2), 3), 9);

在这里，BinOp 是对 T 泛型的。
BiOp::<T>::new 通过 Fn(T, T) -> T 接受闭包界限。

值得注意的是，在 BinOp 中，T 并不受特质的约束。
闭包包装器只移动参数和返回值，因此它们不需要了解有关类型的其他信息。

标记

闭包包装器可以声明为具有标记特性。只需在函数签名后添加 | 和由加号前缀的标记特性列表即可。在 Fn 特性族中，| 符号不被使用，但由于声明性宏的限制，这里需要它。

它们将被添加到包含类型的界限上。如果它们是自动特性，它们也将为包装器类型实现。

tiny_fn! {
    struct Foo = Fn(a: i32, b: i32) -> i32 | + Send;
}

let foo: Foo = Foo::new(|a, b| a + b);

std::thread::spawn(move || {
  foo.call();
});

特殊泛型参数

tiny_fn! 宏生成的闭包包装器除了宏调用者指定的泛型类型外，总是有两个泛型参数