Struct Specializer

pub struct Specializer<T, U, F>(/* private fields */);

Specialized behavior runner (Owned -> Owned)

Implementations

impl<T, U, F> Specializer<T, U, F>

where F: FnOnce(T) -> U, T: 'static, U: 'static,

pub const fn new(params: T, f: F) -> Self

Create a new specializer with a fallback function.

pub fn specialize<P, R>( self, f: impl FnOnce(P) -> R, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where P: 'static, R: 'static,

Specialize on the parameter and the return type of the closure.

use specializer::Specializer;

fn specialized<T, U>(ty: T) -> U
where
    T: 'static,
    U: 'static + From<T> + From<u8>,
{
    Specializer::new(ty, From::from)
        .specialize(|int: i32| -> i32 { int * 2 })
        .specialize_param(|int: u8| { U::from(int * 3) })
        .run()
}

assert_eq!(specialized::<i16, i32>(3), 3);
assert_eq!(specialized::<i32, i32>(3), 6);
assert_eq!(specialized::<u8, i32>(3), 9);

pub fn specialize_map<P, R>( self, p: impl FnOnce(P) -> P, f: impl FnOnce(T) -> U, r: impl FnOnce(R) -> R, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where P: 'static, R: 'static,

Specialize on the parameter and the return type of the closure, mapping both.

use std::convert;

use specializer::Specializer;

fn specialized<T, U>(ty: T) -> U
where
    T: 'static,
    U: 'static + From<T>,
{
    Specializer::new(ty, From::from)
        .specialize(|int: i32| -> i32 { int * 2 })
        .specialize_map(
            |int: u8| int * 3,
            From::from,
            convert::identity::<U>,
        )
        .run()
}

assert_eq!(specialized::<i16, i32>(3), 3);
assert_eq!(specialized::<i32, i32>(3), 6);
assert_eq!(specialized::<u8, i32>(3), 9);

pub fn specialize_param<P>( self, f: impl FnOnce(P) -> U, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where P: 'static,

Specialize on the parameter of the closure.

use specializer::Specializer;

fn specialized<T>(ty: T) -> String
where
    T: 'static
{
    let fallback = |_| "unknown".to_owned();

    Specializer::new(ty, fallback)
        .specialize_param(|int: i32| (int * 2).to_string())
        .specialize_param(|string: String| string)
        .run()
}

assert_eq!(specialized(3), "6");
assert_eq!(specialized("Hello world".to_string()), "Hello world");
assert_eq!(specialized(()), "unknown");

pub fn specialize_return<R>( self, f: impl FnOnce(T) -> R, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where R: 'static,

Specialize on the return type of the closure.

use specializer::Specializer;

fn specialized<T>(int: i32) -> T
where
    T: 'static + Default
{
    let fallback = |_| -> T { Default::default() };

    Specializer::new(int, fallback)
        .specialize_return(|int| -> i32 { int * 2 })
        .specialize_return(|int| -> String { int.to_string() })
        .run()
}

assert_eq!(specialized::<i32>(3), 6);
assert_eq!(specialized::<String>(3), "3");
assert_eq!(specialized::<u8>(3), 0);

pub fn specialize_map_param<P>( self, p: impl FnOnce(P) -> P, f: impl FnOnce(T) -> U, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where P: 'static,

Specialize on the parameter and the return type of the closure, mapping the parameter.

use std::convert;

use specializer::Specializer;

fn specialized<T, U>(ty: T) -> U
where
    T: 'static,
    U: 'static + From<T>,
{
    Specializer::new(ty, From::from)
        .specialize(|int: i32| -> i32 { int * 2 })
        .specialize_map_param(|int: u8| int * 3, From::from)
        .run()
}

assert_eq!(specialized::<i16, i32>(3), 3);
assert_eq!(specialized::<i32, i32>(3), 6);
assert_eq!(specialized::<u8, i32>(3), 9);

pub fn specialize_map_return<R>( self, f: impl FnOnce(T) -> U, r: impl FnOnce(R) -> R, ) -> Specializer<T, U, impl FnOnce(T) -> U>

where R: 'static,

Specialize on the parameter and the return type of the closure, mapping the parameter.

use std::convert;

use specializer::Specializer;

fn specialized<T, U>(ty: T) -> U
where
    T: 'static,
    U: 'static + From<T>,
{
    Specializer::new(ty, From::from)
        .specialize_map_return(From::from, |int: i16| int * 2)
        .specialize_map_param(|int: u8| int * 3, From::from)
        .run()
}

assert_eq!(specialized::<i16, i32>(3), 3);
assert_eq!(specialized::<i8, i16>(3), 6);
assert_eq!(specialized::<u8, i32>(3), 9);

pub fn run(self) -> U

Run the specializer.

Trait Implementations

impl<T: Debug, U: Debug, F: Debug> Debug for Specializer<T, U, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.