Struct FnBrand 

pub struct FnBrand<PtrBrand: RefCountedPointer>(/* private fields */);

Generic function brand parameterized by reference-counted pointer choice.

Trait Implementations

impl<P: UnsizedCoercible> Category for FnBrand<P>

fn identity<'a, A>() -> <Self as Kind_140eb1e35dc7afb3>::Of<'a, A, A>

Returns the identity morphism.

The identity morphism is a function that maps every object to itself, wrapped in the pointer type.

Type Signature

forall self a. Category self => self a a

Type Parameters

• 'a: The lifetime of the morphism.
• A: The type of the object.

Returns

The identity morphism.

Examples

use fp_library::{brands::*, functions::*};

let id = category_identity::<RcFnBrand, i32>();
assert_eq!(id(5), 5);

impl<PtrBrand: Clone + RefCountedPointer> Clone for FnBrand<PtrBrand>

fn clone(&self) -> FnBrand<PtrBrand>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: UnsizedCoercible> CloneableFn for FnBrand<P>

fn new<'a, A, B>(f: impl 'a + Fn(A) -> B) -> <Self as CloneableFn>::Of<'a, A, B>

Creates a new cloneable function wrapper.

This function wraps the provided closure f into a pointer-wrapped cloneable function.

Type Signature

forall a b. (a -> b) -> a -> b

Type Parameters

• 'a: The lifetime of the function and its captured data.
• A: The input type of the function.
• B: The output type of the function.

Parameters

• f: The closure to wrap.
• _: The input value to the function.

Returns

The wrapped cloneable function.

Examples

use fp_library::{brands::*, functions::*};

let f = cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2);
assert_eq!(f(5), 10);

type Of<'a, A, B> = <FnBrand<P> as Kind_140eb1e35dc7afb3>::Of<'a, A, B>

The type of the cloneable function wrapper.

impl<PtrBrand: Debug + RefCountedPointer> Debug for FnBrand<PtrBrand>

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

Formats the value using the given formatter.

impl<PtrBrand: Default + RefCountedPointer> Default for FnBrand<PtrBrand>

fn default() -> FnBrand<PtrBrand>

Returns the “default value” for a type.

impl<P: UnsizedCoercible> Function for FnBrand<P>

fn new<'a, A, B>(f: impl 'a + Fn(A) -> B) -> <Self as Function>::Of<'a, A, B>

Creates a new function wrapper.

This function wraps the provided closure f into a pointer-wrapped function.

Type Signature

forall a b. (a -> b) -> a -> b

Type Parameters

• 'a: The lifetime of the function and its captured data.
• A: The input type of the function.
• B: The output type of the function.

Parameters

• f: The closure to wrap.
• _: The input value to the function.

Returns

The wrapped function.

Examples

use fp_library::{brands::*, functions::*};

let f = fn_new::<RcFnBrand, _, _>(|x: i32| x * 2);
assert_eq!(f(5), 10);

type Of<'a, A, B> = <FnBrand<P> as Kind_140eb1e35dc7afb3>::Of<'a, A, B>

The type of the function wrapper.

impl<PtrBrand: Hash + RefCountedPointer> Hash for FnBrand<PtrBrand>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P: UnsizedCoercible> Kind_140eb1e35dc7afb3 for FnBrand<P>

Generated implementation of Kind_140eb1e35dc7afb3 for FnBrand < P >.

type Of<'a, A, B> = <P as RefCountedPointer>::CloneableOf<dyn Fn(A) -> B + 'a>

The applied type.

impl<PtrBrand: Ord + RefCountedPointer> Ord for FnBrand<PtrBrand>

fn cmp(&self, other: &FnBrand<PtrBrand>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<PtrBrand: PartialEq + RefCountedPointer> PartialEq for FnBrand<PtrBrand>

fn eq(&self, other: &FnBrand<PtrBrand>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<PtrBrand: PartialOrd + RefCountedPointer> PartialOrd for FnBrand<PtrBrand>

fn partial_cmp(&self, other: &FnBrand<PtrBrand>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P: UnsizedCoercible> Semigroupoid for FnBrand<P>

fn compose<'a, B: 'a, C: 'a, D: 'a>( f: <Self as Kind_140eb1e35dc7afb3>::Of<'a, C, D>, g: <Self as Kind_140eb1e35dc7afb3>::Of<'a, B, C>, ) -> <Self as Kind_140eb1e35dc7afb3>::Of<'a, B, D>

Takes morphisms f and g and returns the morphism f . g (f composed with g).

This method composes two pointer-wrapped functions f and g to produce a new function that represents the application of g followed by f.

Type Signature

forall self b c d. Semigroupoid self => (self c d, self b c) -> self b d

Type Parameters

• 'a: The lifetime of the morphisms.
• B: The source type of the first morphism.
• C: The target type of the first morphism and the source type of the second morphism.
• D: The target type of the second morphism.

Parameters

• f: The second morphism to apply (from C to D).
• g: The first morphism to apply (from B to C).

Returns

The composed morphism (from B to D).

Examples

use fp_library::{brands::*, classes::*, functions::*};

let f = cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2);
let g = cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x + 1);
let h = semigroupoid_compose::<RcFnBrand, _, _, _>(f, g);
assert_eq!(h(5), 12); // (5 + 1) * 2

impl<P: SendUnsizedCoercible> SendCloneableFn for FnBrand<P>

fn send_cloneable_fn_new<'a, A, B>( f: impl 'a + Fn(A) -> B + Send + Sync, ) -> Self::SendOf<'a, A, B>

Creates a new thread-safe cloneable function wrapper.

This function wraps the provided closure f into a pointer-wrapped thread-safe cloneable function.

Type Signature

forall self a b. SendCloneableFn self => (a -> b) -> self a b

Type Parameters

• 'a: The lifetime of the function and its captured data.
• A: The input type of the function.
• B: The output type of the function.

Parameters

• f: The closure to wrap.

Returns

The wrapped thread-safe cloneable function.

Examples

use fp_library::{brands::*, functions::*};

let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|x: i32| x * 2);
assert_eq!(f(5), 10);

type SendOf<'a, A, B> = <P as SendRefCountedPointer>::SendOf<dyn Fn(A) -> B + Sync + Send + 'a>

The type of the thread-safe cloneable function wrapper.

impl<PtrBrand: Copy + RefCountedPointer> Copy for FnBrand<PtrBrand>

impl<PtrBrand: Eq + RefCountedPointer> Eq for FnBrand<PtrBrand>

impl<PtrBrand: RefCountedPointer> StructuralPartialEq for FnBrand<PtrBrand>