Struct CausalMultiVectorWitness 

pub struct CausalMultiVectorWitness;

Trait Implementations

impl Adjunction<CausalMultiVectorWitness, CausalMultiVectorWitness, Metric> for CausalMultiVectorWitness

fn unit<A>(ctx: &Metric, a: A) -> CausalMultiVector<CausalMultiVector<A>>

where A: Satisfies<NoConstraint> + Clone,

The Unit of the Adjunction: A → R<L>

fn counit<B>(_ctx: &Metric, lrb: CausalMultiVector<CausalMultiVector<B>>) -> B

where B: Satisfies<NoConstraint> + Clone,

The Counit of the Adjunction: L<R> → B

fn left_adjunct<A, B, F>(ctx: &Metric, a: A, f: F) -> CausalMultiVector<B>

where A: Satisfies<NoConstraint> + Clone, B: Satisfies<NoConstraint>, F: Fn(CausalMultiVector<A>) -> B,

The Left Adjunct: (L → B) → (A → R)

fn right_adjunct<A, B, F>(_ctx: &Metric, la: CausalMultiVector<A>, f: F) -> B

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

The Right Adjunct: (A → R) → (L → B)

impl Applicative<CausalMultiVectorWitness> for CausalMultiVectorWitness

fn apply<A, B, Func>( f_ab: CausalMultiVector<Func>, f_a: CausalMultiVector<A>, ) -> CausalMultiVector<B>

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

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

impl CoMonad<CausalMultiVectorWitness> for CausalMultiVectorWitness

fn extract<A>(fa: &CausalMultiVector<A>) -> A

where A: Satisfies<NoConstraint> + Clone,

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

fn extend<A, B, Func>( fa: &CausalMultiVector<A>, f: Func, ) -> CausalMultiVector<B>

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

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

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

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

Duplicates the comonadic context.

impl Foldable<CausalMultiVectorWitness> for CausalMultiVectorWitness

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

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

Reduces the elements of the structure to a single value by applying a function.

impl Functor<CausalMultiVectorWitness> for CausalMultiVectorWitness

fn fmap<A, B, Func>(fa: CausalMultiVector<A>, f: Func) -> CausalMultiVector<B>

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

Applies a function f to the value inside the container m_a.

impl HKT for CausalMultiVectorWitness

type Constraint = NoConstraint

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

type Type<T> = CausalMultiVector<T>

The Generic Associated Type (GAT) that represents the type constructor. The <T> is the “hole” in the type constructor (e.g., Option<T>).

impl Monad<CausalMultiVectorWitness> for CausalMultiVectorWitness

fn bind<A, B, Func>(ma: CausalMultiVector<A>, f: Func) -> CausalMultiVector<B>

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

Chains a computation from an effectful value, flattening the result. This is the core sequencing operation of a Monad.

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

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

Flatten a nested structure into a single layer.

impl Pure<CausalMultiVectorWitness> for CausalMultiVectorWitness

fn pure<T>(value: T) -> CausalMultiVector<T>

where T: Satisfies<NoConstraint>,

Lifts a pure value into the context F::Type<T>.