Enum eff::coproduct::Either

pub enum Either<E, Rest> where
    E: Effect,  {
    A(E, TypedContext<E>),
    B(Rest),
}

The coproduct of effects

Variants

A(E, TypedContext<E>)B(Rest)

Methods

impl<F, Rest> Either<F, Rest> where
    F: Effect, 

pub fn inject<E, Index>(effect: E, cx: TypedContext<E>) -> Self where
    E: Effect,
    Self: Inject<E, Index>, 

Construct Self using an effect and a task context

pub fn uninject<E, Index>(self) -> Result<(E, TypedContext<E>), Self::Remainder> where
    E: Effect,
    Self: Uninject<E, Index>, 

Retrieve an effect and a task context from self if the type matches

Errors

If self holds an effect of a different type, this method returns an error.

pub fn embed<Target, Indices>(self) -> Target where
    Self: Embed<Target, Indices>, 

Embed self into the target type

pub fn subset<Target, Indices>(self) -> Result<Target, Self::Remainder> where
    Self: Subset<Target, Indices>, 

Take the subset of Self

Trait Implementations

impl<E, Rest> Inject<E, Zero> for Either<E, Rest> where
    E: Effect, 

fn inject(effect: E, cx: TypedContext<E>) -> Self

Construct a coproduct from an effect and a task context

impl<E, F, Rest, Index> Inject<E, Succ<Index>> for Either<F, Rest> where
    E: Effect,
    F: Effect,
    Rest: Inject<E, Index>, 

fn inject(effect: E, cx: TypedContext<E>) -> Self

Construct a coproduct from an effect and a task context

impl<E, Rest> Uninject<E, Zero> for Either<E, Rest> where
    E: Effect, 

type Remainder = Rest

The other effect types of this coproduct

fn uninject(self) -> Result<(E, TypedContext<E>), Self::Remainder>

Retrieve an effect and a sender from self if the type matches

impl<E, F, Rest, Index> Uninject<E, Succ<Index>> for Either<F, Rest> where
    E: Effect,
    F: Effect,
    Rest: Uninject<E, Index>, 

type Remainder = Either<F, <Rest as Uninject<E, Index>>::Remainder>

The other effect types of this coproduct

fn uninject(self) -> Result<(E, TypedContext<E>), Self::Remainder>

Retrieve an effect and a sender from self if the type matches

impl<E, Rest, Target, HeadIndex, TailIndices> Embed<Target, Either<Wrap<HeadIndex>, TailIndices>> for Either<E, Rest> where
    E: Effect,
    Target: Inject<E, HeadIndex>,
    Rest: Embed<Target, TailIndices>, 

fn embed(self) -> Target

Embed self into the target type

impl<E, Rest> Subset<!, !> for Either<E, Rest> where
    E: Effect, 

type Remainder = Self

The other effect types

fn subset(self) -> Result<!, Self::Remainder>

Take the subset of Self

impl<T, E, Rest, HeadIndex, TailIndices> Subset<Either<E, Rest>, Either<Wrap<HeadIndex>, TailIndices>> for T where
    E: Effect,
    T: Uninject<E, HeadIndex>,
    <T as Uninject<E, HeadIndex>>::Remainder: Subset<Rest, TailIndices>, 

type Remainder = <<T as Uninject<E, HeadIndex>>::Remainder as Subset<Rest, TailIndices>>::Remainder

The other effect types

fn subset(self) -> Result<Either<E, Rest>, Self::Remainder>

Take the subset of Self