tiny-fn 0.1.9

//!
//! Have you ever being placing closure into [`Box<dyn Fn(...)>`] and wondered:
//! "Is there a crate to avoid heap allocations for small closures?"
//!
//! Wonder no more, this is the crate.
//!
//! # How to use
//!
//! This crate provides declarative macro [`tiny_fn!`] to generate closure wrappers
//! able store closure erasing its type.
//!
//! Generated closure wrappers avoid heap allocations when wrapped closure fits inline storage.
//!
//! The macro is designed to be easy to write with simple syntax that mostly reuse constructs already existing in Rust.\
//! Behavior of generated wrappers should be obvious from the first glance.
//!
//! # Example
//!
//! ```
//! # use tiny_fn::tiny_fn;
//! tiny_fn! {
//!     struct Foo = Fn(a: i32, b: i32) -> i32;
//! }
//!
//! let foo: Foo = Foo::new(|a, b| a + b);
//! assert_eq!(3, foo.call(1, 2));
//! ```
//!
//! Macro expands to `struct Foo` definition with two public methods.
//!
//! * `Foo::new` accepts any value that implements [`Fn(i32, i32) -> i32`] and returns new instance of `Foo`.
//! * `Foo::call` follows signature specified to the macro. e.g. `Foo::call` accepts `a: i32` and `b: i32` and returns [`i32`].\
//!   Plainly `Foo::call` calls closure from which this instance of `Foo` was crated using `a` and `b` arguments at the same positions.
//!
//! [`tiny_fn!`] macro supports defining multiple items at once.
//!
//! ```
//! # use tiny_fn::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!");
//! ```
//!
//! # Visibility
//!
//! [`tiny_fn!`] macro supports visibility qualifiers.
//!
//!
//! ```
//! # use tiny_fn::tiny_fn;
//! tiny_fn! {
//!     pub struct Foo = Fn(a: i32, b: i32) -> i32;
//!     struct Bar = Fn() -> String;
//!     pub(crate) struct Baz = Fn();
//! }
//! ```
//!
//! # Attributes
//!
//! [`tiny_fn!`] macro supports item attributes, including documentation.
//!
//! ```
//! # use tiny_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*`] traits family
//!
//! [`tiny_fn!`] macro can generate closure wrappers for any of the [`Fn*`] traits family.
//!
//! ```
//! # use tiny_fn::tiny_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` can wrap only closures that are callable when immutably borrowed. And so `A::call` takes `&self`.
//! * `B` can wrap only closures that are callable when borrowed. And so `B::call` takes `&mut self`.
//! * `C` can wrap any closures, even ones that are callable once. And so `C::call` takes `self`.
//!
//! # Generics
//!
//! Closure wrappers can be declared generic over number of types and those types should be used in function signature.
//!
//! ```
//! # use tiny_fn::tiny_fn;
//! 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);
//! ```
//!
//! Here `BinOp` is generic over `T`.\
//! `BiOp::<T>::new` accepts closures bounds by [`Fn(T, T) -> T`].
//!
//! Notably `T` is not constrained by traits in `BinOp`.\
//! Closure wrappers only move arguments and return values, so they don't need to know anything else about the type.
//!
//! # Markers
//!
//! Closure wrappers can be declared with marker traits.
//! Simply add `|` and list of `+` prefixed marker traits after function signature.
//! In Fn traits family `|` symbol is not used, but here it is required due to declarative macro limitations.
//!
//! They will be added to bounds on contained types.
//! And if autotraits, they will be implemented for the wrapper type as well.
//!
//! ```rust
//! # use tiny_fn::tiny_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(1, 2);
//! });
//! ```
//! # Special generic parameters
//!
//! Closure wrapper generated by [`tiny_fn!`] macro always have two generic parameters besides generic types specified by macro caller:
//! * Lifetime `'closure`.\
//!   Wrapper contains closures bound by `'closure` lifetime.
//! * Constant `INLINE_SIZE: usize`.\
//!   Closures with size up to `INLINE_SIZE` and alignment requirement not exceeding [`tiny_fn::ALIGN`] will be inlined into wrapper structure directly.\
//!   Otherwise heap allocation will occur.\
//!   `INLINE_SIZE` parameter is defaulted to [`tiny_fn::DEFAULT_INLINE_SIZE`].
//!
//! [`Box<dyn Fn(...)>`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
//! [`Fn(i32, i32) -> i32`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
//! [`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
//! [`Fn(T, T) -> T`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
//! [`tiny_fn::ALIGN`]: `ALIGN`
//! [`tiny_fn::DEFAULT_INLINE_SIZE`]: `DEFAULT_INLINE_SIZE`

#![no_std]

extern crate alloc;

/// Inline storage alignment.
/// Closures with stricter alignment requirements will be heap allocated by wrapper
/// even if size fits.
pub const ALIGN: usize = core::mem::align_of::<crate::private::InlineStorage<1>>();

/// Default value for `INLINE_SIZE` parameter of closure wrappers generated by [`tiny_fn!`] macro.
pub const DEFAULT_INLINE_SIZE: usize = core::mem::size_of::<[usize; 3]>();

/// Content of this module is not public API.
/// It is used by macro output.
#[doc(hidden)]
pub mod private {
    pub use alloc::boxed::Box;
    pub use core::{
        mem::{align_of, size_of, transmute, ManuallyDrop, MaybeUninit},
        ptr::{copy_nonoverlapping, drop_in_place, read, NonNull},
    };

    pub trait Closure {
        type Inner;
    }

    #[repr(C)]
    pub struct VTable<D = unsafe fn(), C = unsafe fn()> {
        pub drop: D,
        pub call: C,
    }

    #[repr(C, align(16))]
    #[derive(Clone, Copy)]
    pub struct InlineStorage<const INLINE_SIZE: usize> {
        pub storage: MaybeUninit<[u8; INLINE_SIZE]>,
    }

    pub type StoragePtr<const INLINE_SIZE: usize> = NonNull<InlineStorage<INLINE_SIZE>>;

    pub type DropFn<const INLINE_SIZE: usize> = unsafe fn(StoragePtr<INLINE_SIZE>);
}

#[doc(hidden)]
#[macro_export]
macro_rules! private_tiny_fn {
    (@call $(<$($hrl:lifetime),+>)? Fn $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        fn call $(< $($hrl),+ >)? (&self, $($arg_name: $arg_type),*) $(-> $ret)? {
            unsafe {
                match self.vtable {
                    None => (*self.payload.boxed.closure)($($arg_name),*),
                    Some(vtable) => {
                        let call_fn: CallFn< $($($lt,)* $($t,)*)? INLINE_SIZE> = $crate::private::transmute(vtable.call);
                        call_fn(
                            $crate::private::NonNull::from(&self.payload.inline),
                            $($arg_name),*
                        )
                    }
                }
            }
        }
    };

    (@call $(<$($hrl:lifetime),+>)? FnMut $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        fn call $(< $($hrl),+ >)? (&mut self, $($arg_name: $arg_type),*) $(-> $ret)? {
            unsafe {
                match self.vtable {
                    None => (*(*self.payload.boxed).closure)($($arg_name),*),
                    Some(vtable) => {
                        let call_fn: CallFn< $($($lt,)* $($t,)*)? INLINE_SIZE> = $crate::private::transmute(vtable.call);
                        call_fn(
                            $crate::private::NonNull::from(&mut self.payload.inline),
                            $($arg_name),*
                        )
                    }
                }
            }
        }
    };

    (@call $(<$($hrl:lifetime),+>)? FnOnce $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        fn call $(< $($hrl),+ >)? (self, $($arg_name: $arg_type),*) $(-> $ret)? {
            let mut me = $crate::private::ManuallyDrop::new(self);
            unsafe {
                match me.vtable {
                    None => ($crate::private::ManuallyDrop::take(&mut me.payload.boxed).closure)($($arg_name),*),
                    Some(vtable) => {
                        let call_fn: CallFn< $($($lt,)* $($t,)*)? INLINE_SIZE> = $crate::private::transmute(vtable.call);
                        call_fn(
                            $crate::private::NonNull::from(&mut (*me).payload.inline),
                            $($arg_name),*
                        )
                    }
                }
            }
        }
    };


    (@call_outer $(<$($hrl:lifetime),+>)? Fn $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        /// Calls wrapped closure
        /// and returns it result.
        #[allow(dead_code)]
        pub fn call $(<$($hrl),+>)? (&self, $($arg_name: $arg_type),*) $(-> $ret)? {
            self.inner.call($($arg_name,)*)
        }
    };

    (@call_outer $(<$($hrl:lifetime),+>)? FnMut $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        /// Calls wrapped closure
        /// and returns it result.
        #[allow(dead_code)]
        pub fn call $(<$($hrl),+>)? (&mut self, $($arg_name: $arg_type),*) $(-> $ret)? {
            self.inner.call($($arg_name,)*)
        }
    };

    (@call_outer $(<$($hrl:lifetime),+>)? FnOnce $(< $($lt:lifetime,)*  $($t:ident,)* >)? ($($arg_name:ident: $arg_type:ty),* $(,)?) $( -> $ret:ty)?) => {
        /// Calls wrapped closure
        /// and returns it result.
        #[allow(dead_code)]
        pub fn call $(<$($hrl),+>)? (self, $($arg_name: $arg_type),*) $(-> $ret)? {
            self.inner.call($($arg_name,)*)
        }
    };

    (@inline_call_cast Fn $ptr:ident) => {
        (*(*$ptr.as_ptr()).storage.as_ptr().cast::<F>())
    };

    (@inline_call_cast FnMut $ptr:ident) => {
        (*(*$ptr.as_ptr()).storage.as_mut_ptr().cast::<F>())
    };

    (@inline_call_cast FnOnce $ptr:ident) => {
        $crate::private::read((*$ptr.as_ptr()).storage.as_mut_ptr().cast::<F>())
    };

    // (@get_self_bounds [$($lifetimes:lifetime)*] [$($traits:path)*] [$(,)?]) => {
    //     $($traits +)* $($lifetimes +)* 'closure
    // };

    // (@get_self_bounds [$($lifetimes:lifetime)*] [$($traits:path)*] [Self: $(+ $self_lifetimes:lifetime)* $(+ $self_traits:path)*  $(, $tail:tt: $(+ $tail_lifetimes:lifetime)* $(+ $tail_traits:path)*,),* $(,)?]) => {
    //     $crate::private_tiny_fn!(@get_self_bounds [$($lifetimes)* $($self_lifetimes)*] [$($traits)* $($self_traits)*] [$( $($tail: $(+ $tail_lifetimes)* $(+ $tail_traits)*),* )*])
    // };

    // (@get_self_bounds [$($lifetimes:lifetime)*] [$($traits:path)*] [$not_self:tt: $(+ $not_self_lifetimes:lifetime)* $(+ $not_self_traits:path)*  $(, $tail:tt: $(+ $tail_lifetimes:lifetime)* $(+ $tail_traits:path)*,),* $(,)?]) => {
    //     $crate::private_tiny_fn!(@get_self_bounds [$($lifetimes)*] [$($traits)*] [$( $($tail: $(+ $tail_lifetimes)* $(+ $tail_traits)*),* )*])
    // };

    // (@get_generic_bounds [$($lt:ident: $lifetimes:lifetime,)*] [$($tt:ident: $traits:path,)*] []) => {
    //     $($lt : $lifetimes,)*
    //     $($tt : $traits,)*
    //     Self: 'closure,
    // };

    // (@get_generic_bounds [$($lt:ident: $lifetimes:lifetime,)*] [$($tt:ident: $traits:path,)*] [Self: $(+ $self_lifetimes:lifetime)* $(+ $self_traits:path)*  $(, $tail:tt: $(+ $tail_lifetimes:lifetime)* $(+ $tail_traits:path)*,),* $(,)?]) => {
    //     $crate::private_tiny_fn!(@get_generic_bounds [$($lt: $lifetimes,)*] [$($tt: $traits,)*] [$( $($tail: $(+ $tail_lifetimes)* $(+ $tail_traits)*),* )*])
    // };

    // (@get_generic_bounds [$($lt:ident: $lifetimes:lifetime,)*] [$($tt:ident: $traits:path,)*] [$not_self:tt: $(+ $not_self_lifetimes:lifetime)* $(+ $not_self_traits:path)*  $(, $tail:tt: $(+ $tail_lifetimes:lifetime)* $(+ $tail_traits:path)*,),* $(,)?]) => {
    //     $crate::private_tiny_fn!(@get_generic_bounds [$($lt: $lifetimes,)* $($not_self: $not_self_lifetimes,)*] [$($tt: $traits,)* $($not_self: $not_self_traits.)*] [$( $($tail: $(+ $tail_lifetimes)* $(+ $tail_traits)*),* )*])
    // };
}

/// Defines new structure type.
/// This type will be constructible from any closure
/// that implement specified [`Fn*`] trait.
/// Closures that fits into inline storage will be placed there.
/// Otherwise closure will be boxed.
/// And it will have `call` method with the same signature as the closure.
///
/// Defined type can have generic parameters that can be used in function signature.
/// It will always have additional `const INLINE_SIZE: usize` generic parameter,
/// that controls size of the inline storage. Alignment of the inline storage is hardcoded to 16
/// which is enough for any primitive type and thus fits most of the types.
///
/// [`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
#[macro_export]
macro_rules! tiny_fn {
    ($(
        $(#[$meta:meta])*
        $vis:vis struct $name:ident $(< $($lt:lifetime),* $(,)? $($t:ident),* >)? =
        $(<$($hrl:lifetime),+>)?
        $fun:ident ($(
            $arg_name:ident: $arg_type:ty
        ),* $(,)?)
        $( -> $ret:ty)?
        $(| $(+ $markers:path)+)?
        $(where $( $wt:tt: $(+ $wtl:lifetime)* $(+ $wtb:path)* ),*)?
        ;
    )*) => {
        $(
            const _: () = {
                type CallFn< $($($lt,)* $($t,)*)? const INLINE_SIZE: usize> = $(for<$($hrl),+>)? unsafe fn($crate::private::StoragePtr<INLINE_SIZE>, $($arg_type),*) $( -> $ret)?;

                struct BoxedFn <'closure $( $(, $lt)* $(, $t)*)?>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    closure: $crate::private::Box<dyn $(for<$($hrl),+>)? $fun($($arg_type),*) $(-> $ret)? $($(+ $markers)+)? + 'closure>,
                }

                #[doc(hidden)]
                union TinyClosurePayload<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    inline: $crate::private::InlineStorage<INLINE_SIZE>,
                    boxed: $crate::private::ManuallyDrop<BoxedFn<'closure $($(, $lt)* $(, $t)*)?>>,
                }

                pub struct TinyClosure<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    vtable: Option<&'static $crate::private::VTable>,
                    payload: TinyClosurePayload<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>,
                }

                impl<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize> Drop for TinyClosure<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    fn drop(&mut self) {
                        unsafe {
                            match self.vtable {
                                None => $crate::private::ManuallyDrop::drop(&mut self.payload.boxed),
                                Some(vtable) => {
                                    let drop_fn: $crate::private::DropFn<INLINE_SIZE> = $crate::private::transmute(vtable.drop);
                                    drop_fn($crate::private::NonNull::from(&mut self.payload.inline));
                                }
                            }
                        }
                    }
                }

                impl<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize> TinyClosure<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    fn new<F>(f: F) -> Self
                    where
                        F: $(for<$($hrl),+>)? $fun ($($arg_type),*) $( -> $ret)? $($(+ $markers)+)? + 'closure,
                    {
                        let size_fits = $crate::private::size_of::<F>() <= INLINE_SIZE;
                        let align_fits = $crate::private::align_of::<F>() <= $crate::ALIGN;

                        if size_fits && align_fits {
                            let mut inline = $crate::private::InlineStorage {
                                storage: $crate::private::MaybeUninit::uninit(),
                            };

                            unsafe {
                                let storage_f = inline.storage.as_mut_ptr() as *mut $crate::private::MaybeUninit<F>;
                                (*storage_f).write(f);
                            }

                            let vtable = unsafe {
                                $crate::private::transmute(&$crate::private::VTable::< $crate::private::DropFn<INLINE_SIZE>, CallFn< $($($lt,)* $($t,)*)? INLINE_SIZE>> {
                                    drop: |ptr: $crate::private::StoragePtr<INLINE_SIZE>| {
                                        $crate::private::drop_in_place(ptr.cast::<F>().as_ptr());
                                    },
                                    call: |ptr: $crate::private::StoragePtr<INLINE_SIZE> $(, $arg_name)*| {
                                        $crate::private_tiny_fn!(@inline_call_cast $fun ptr)($($arg_name),*)
                                    }
                                })
                            };
                            TinyClosure {
                                vtable: Some(vtable),
                                payload: TinyClosurePayload {
                                    inline,
                                }
                            }
                        } else {
                            let boxed_fn = BoxedFn {
                                closure: $crate::private::Box::new(f),
                            };

                            TinyClosure {
                                vtable: None,
                                payload: TinyClosurePayload {
                                    boxed: $crate::private::ManuallyDrop::new(boxed_fn),
                                }
                            }
                        }
                    }

                    $crate::private_tiny_fn!(@call $(<$($hrl),+>)? $fun $(< $($lt,)*  $($t,)* >)? ($($arg_name: $arg_type),*) $( -> $ret)?);
                }

                impl<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize> $crate::private::Closure for $name<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>
                $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
                {
                    type Inner = TinyClosure<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>;
                }
            };

            #[repr(transparent)]
            $(#[$meta])*
            $vis struct $name<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize = { $crate::DEFAULT_INLINE_SIZE }>
            $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
            {
                #[allow(dead_code)]
                inner: < $name<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE> as $crate::private::Closure>::Inner,
            }

            impl<'closure, $($($lt,)* $($t,)*)? const INLINE_SIZE: usize> $name<'closure, $($($lt,)* $($t,)*)? INLINE_SIZE>
            $(where $( $($wt: $wtl,)* $($wt: $wtb,)* ),*)?
            {
                /// Constructs new instance of wrapper from specified closure.
                /// Closure will be boxed if it doesn't fit inline storage.
                #[inline]
                pub fn new<F>(f: F) -> Self
                where
                    F: $(for<$($hrl),+>)? $fun ($($arg_type),*) $( -> $ret)? $($(+ $markers)+)? + 'closure,
                {
                    $name {
                        inner: < < $name < $($($t,)*)? INLINE_SIZE > as $crate::private::Closure>::Inner>::new(f),
                    }
                }

                $crate::private_tiny_fn!(@call_outer $(<$($hrl),+>)? $fun $(< $($lt,)*  $($t,)* >)? ($($arg_name: $arg_type),*) $( -> $ret)?);
            }
        )*
    };
}

#[cfg(feature = "example")]
pub mod example {
    //! This module contains a few example declarations with [`tiny_fn!`] macro.\
    //! And their usage in the section below.
    //!
    //! # Usage
    //!
    //! ```
    //! # extern crate alloc;
    //! # use tiny_fn::example::*;
    //! # use alloc::{borrow::ToOwned, format};
    //! #
    //! let binop: BinOp::<i32, 24> = BinOp::new(|a, b| a + b);
    //! assert_eq!(3, binop.call(1, 2));
    //!
    //! let a = "Hello".to_owned();
    //! let b = "world".to_owned();
    //! let make_string = MakeString::<32>::new(move || format!("{a} {b}!"));
    //!
    //! assert_eq!(make_string.call(), "Hello world!");
    //! ```

    tiny_fn! {
        /// Contains any binary operation for a specific type.
        /// That takes two values of that type
        /// and returns value of that type.
        pub struct BinOp<T> = Fn(a: T, b: T) -> T;

        pub struct MakeString = Fn() -> alloc::string::String;
    }
}

#[cfg(test)]
mod tests {
    use alloc::string::String;

    #[test]
    fn test() {
        use alloc::rc::Rc;

        tiny_fn! {
            pub(crate) struct Foo<T> = FnMut(a: &T, b: T) -> T | + Send;
            pub struct Bar = FnOnce(b: u8) -> alloc::string::String;
            pub struct Baz<'a> = Fn(a: &'a str) -> &'a str | + Send;
            pub struct Hrl = <'a> Fn(a: &'a str) -> &'a str | + Send;
            struct Complex<'a, A, B> = <'b> Fn(a: &'a A, b: &'b B) -> &'a str | + Send where A: + 'a;
        }

        let mut x = 3;
        let mut foo = Foo::<u8>::new(|a, b| {
            x += a + b;
            x
        });
        let bar: Bar<0> = Bar::new(|b| alloc::format!("{}", b));

        assert_eq!(6, foo.call(&1, 2));
        assert_eq!(13, foo.call(&3, 4));

        assert_eq!("3", bar.call(3));

        fn assert_send<T: Send>() {}
        assert_send::<Foo<Rc<u8>>>();
        let s = String::new();

        let baz: Baz = Baz::new(|a: &str| a);

        let _: &'static str = baz.call("Hello, World!");

        // let _: &str = baz.call(&s); // This will not compile, because `s` is not `'static` and `baz` is bound to `'static` lifetime.

        let mut hlp: Hrl = Hrl::new(|a: &str| a);

        let _: &'static str = hlp.call("Hello, World!");

        hlp = Hrl::new(|_| "foo");
        let _: &str = hlp.call(&s); // This compiles because argument's lifetime is not bound by the type.

        let complex: Complex<u8, u8> = Complex::new(|a: &u8, b: &u8| {
            if *a > *b {
                "a is greater"
            } else {
                "b is greater"
            }
        });
    }
}