Crate simple_ref_fn

This crate provides type-erased function wrappers that behave like &dyn Fn(T) -> R and &mut dyn FnMut(T) -> R, but do not require compiler to generate virtual tables.

The following wrapper types are provided:

Type	Behaves like	Send	Sync
RefFn<'a, T, R>	&'a dyn Fn(T) -> R	No	No
RefSyncFn<'a, T, R>	&'a (dyn Fn(T) -> R + Sync)	Yes	Yes
RefFnMut<'a, T, R>	&'a mut dyn FnMut(T) -> R	No	Yes
RefSendFnMut<'a, T, R>	&'a mut (dyn FnMut(T) -> R + Send)	Yes	Yes

Examples

Bind a function with a reference

use simple_ref_fn::{RefFn, StaticRefFunction};

// Define a static function.

struct F;

impl StaticRefFunction<'_, u32, u32> for F {
    type Output = u32;

    fn call(data: &u32, arg: u32) -> Self::Output {
        data + arg
    }
}

// Bind the function with a reference.

let data = 2;
let f: RefFn<u32, u32> = F::bind(&data); // Type-erasure.

assert_eq!(f.call(3), 5);
assert_eq!(f.call(5), 7);
assert_eq!(f.call(7), 9);

Erase the type of a closure

use simple_ref_fn::RefFn;

let data = 2_u32;
let closure = |arg: u32| data + arg;
let f: RefFn<u32, u32> = RefFn::from(&closure);  // Type-erasure.

assert_eq!(f.call(3), 5);
assert_eq!(f.call(5), 7);
assert_eq!(f.call(7), 9);

Structs

RefFn

A simple function wrapper that behaves like a &dyn Fn(T) -> R type, but does not require a virtual table.

RefFnMut

A simple function wrapper that behaves like a &mut dyn FnMut(T) -> R type, but does not require a virtual table.

RefSendFnMut

A simple function wrapper that behaves like a &mut (dyn FnMut(T) -> R + Send) type, but does not require a virtual table.

RefSyncFn

A simple function wrapper that behaves like a &(dyn Fn(T) -> R + Sync) type, but does not require a virtual table.

Traits

StaticRefFunction

A trait for defining a static function will be type erased.

StaticRefMutFunction

A trait for defining a static function that will be type erased.