Struct BoxWitness 

pub struct BoxWitness;

BoxWitness is a zero-sized type that acts as a Higher-Kinded Type (HKT) witness for the Box<T> type constructor. It allows Box to be used with generic functional programming traits like Functor, Applicative, Foldable, and Monad.

By implementing HKT for BoxWitness, we can write generic functions that operate on any type that has the “shape” of Box, without knowing the inner type T.

Constraint

BoxWitness uses NoConstraint, meaning it works with any type T.

Trait Implementations

impl Applicative<BoxWitness> for BoxWitness

fn apply<A, B, Func>( f_ab: <BoxWitness as HKT>::Type<Func>, f_a: <BoxWitness as HKT>::Type<A>, ) -> <BoxWitness as HKT>::Type<B>

where A: Satisfies<NoConstraint> + Clone, B: Satisfies<NoConstraint>, Func: Satisfies<NoConstraint> + FnMut(A) -> B,

Applies a function wrapped in a Box (f_ab) to a value wrapped in a Box (f_a).

impl CoMonad<BoxWitness> for BoxWitness

fn extract<A>(fa: &<Self as HKT>::Type<A>) -> A

where A: Satisfies<NoConstraint> + Clone,

Extracts the value at the current focus of the comonadic context.

fn extend<A, B, Func>( fa: &<Self as HKT>::Type<A>, f: Func, ) -> <Self as HKT>::Type<B>

where A: Satisfies<NoConstraint> + Clone, B: Satisfies<NoConstraint>, Func: FnMut(&<Self as HKT>::Type<A>) -> B,

Extends the comonadic context by applying a function to its observed state.

fn duplicate<A>(fa: &F::Type<A>) -> F::Type<F::Type<A>>

where A: Satisfies<F::Constraint> + Clone, F::Type<A>: Satisfies<F::Constraint> + Clone,

Duplicates the comonadic context.

impl Foldable<BoxWitness> for BoxWitness

fn fold<A, B, Func>(fa: Box<A>, init: B, f: Func) -> B

where Func: FnMut(B, A) -> B,

Folds (reduces) a Box into a single value.

The function f is applied with the initial accumulator and the value inside the Box.

Arguments

• fa: The Box to fold.
• init: The initial accumulator value.
• f: The folding function.

Returns

The accumulated result.

impl Functor<BoxWitness> for BoxWitness

fn fmap<A, B, Func>( m_a: <BoxWitness as HKT>::Type<A>, f: Func, ) -> <BoxWitness as HKT>::Type<B>

where A: Satisfies<NoConstraint>, B: Satisfies<NoConstraint>, Func: FnMut(A) -> B,

Implements the fmap operation for Box<T>.

If the Box contains a value, the function f is applied to value, and the result is wrapped in a new Box.

Arguments

• m_a: The Box to map over.
• f: The function to apply to the value inside the Box.

Returns

A new Box with the function applied to its content.

impl HKT for BoxWitness

type Type<T> = Box<T>

Specifies that BoxWitness represents the Box<T> type constructor.

type Constraint = NoConstraint

The constraint on inner types. Use NoConstraint for fully polymorphic.

impl Monad<BoxWitness> for BoxWitness

fn bind<A, B, Func>( m_a: <BoxWitness as HKT>::Type<A>, f: Func, ) -> <BoxWitness as HKT>::Type<B>

where A: Satisfies<NoConstraint>, B: Satisfies<NoConstraint>, Func: FnMut(A) -> <BoxWitness as HKT>::Type<B>,

Implements the bind operation for Box<T>.

fn join<A>(m_m_a: F::Type<F::Type<A>>) -> F::Type<A>

where A: Satisfies<F::Constraint>, F::Type<A>: Satisfies<F::Constraint>,

Flatten a nested structure into a single layer.

impl Pure<BoxWitness> for BoxWitness

fn pure<T>(value: T) -> <BoxWitness as HKT>::Type<T>

where T: Satisfies<NoConstraint>,

Lifts a pure value into a Box.