Struct coproduct::Coproduct

pub struct Coproduct<T: IndexedDrop>(_);

Can hold any type. You should use CopyableCoproduct if your types are copyable.

Implementations

impl<T: IndexedDrop> Coproduct<T>

pub fn inject<I, X>(x: X) -> Selfwhere
    Self: At<I, X>,

Create a new coproduct that holds the given value.

pub fn uninject<I, X>(self) -> Result<X, <Self as At<I, X>>::Pruned>where
    Self: At<I, X>,

If the coproduct contains an X, returns that value. Otherwise, returns the same coproduct, refined to indicate that it cannot contain X.

This method can be used to do exhaustive case analysis on a coproduct:

let animal: Coproduct!(Cat, Dog) = Coproduct::inject(Dog("Sparky"));

let non_cat = match animal.uninject::<_, Cat>() {
   Ok(_) => unreachable!(),
   Err(non_cat) => non_cat,
};
match non_cat.uninject::<_, Dog>() {
   Ok(dog) => assert_eq!(dog, Dog("Sparky")),
   Err(non_animal) => {
       // There are animals other than cats and dogs? Absurd!
       non_animal.ex_falso()
   }
}

pub fn embed<U, I>(self) -> Uwhere
    Self: Embed<U, I>,

Convert a coproduct into another with more variants.

pub fn split<U, I>(self) -> Result<U, <Self as Split<U, I>>::Remainder>where
    Self: Split<U, I>,

Split a coproduct into two disjoint sets. Returns the active one.

impl<H, T> Coproduct<Union<H, T>>where
    Union<H, T>: IndexedDrop,
    T: IndexedDrop,

pub fn take_head(self) -> Result<H, Coproduct<T>>

Try to take the first variant out. On failure, return the remaining variants.

impl Coproduct<EmptyUnion>

pub fn ex_falso<T>(&self) -> T

From falsehood, anything follows.

Given a coproduct that cannot contain anything, just call this method.

Trait Implementations

impl<I, X, U: IndexedDrop> At<I, X> for Coproduct<U>where
    U: UnionAt<I, X>,
    U::Pruned: IndexedDrop,
    I: Count,

fn inject(x: X) -> Self

fn uninject(self) -> Result<X, Self::Pruned>

type Pruned = Coproduct<<U as UnionAt<I, X>>::Pruned>

impl<T: IndexedClone + IndexedDrop> Clone for Coproduct<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: IndexedDebug + IndexedDrop> Debug for Coproduct<T>

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

Formats the value using the given formatter.

impl<T: IndexedDrop> Drop for Coproduct<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: IndexedDrop, I, U: IndexedDrop> Embed<Coproduct<T>, I> for Coproduct<U>where
    LeakingCoproduct<U>: Embed<LeakingCoproduct<T>, I>,

fn embed(self) -> Coproduct<T>

impl<T> PartialEq<Coproduct<T>> for Coproduct<T>where
    T: IndexedEq + IndexedDrop,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: IndexedDrop, I, U: IndexedDrop, Rem> Split<Coproduct<T>, I> for Coproduct<U>where
    LeakingCoproduct<U>: Split<LeakingCoproduct<T>, I, Remainder = LeakingCoproduct<Rem>>,
    Rem: IndexedDrop,

type Remainder = Coproduct<Rem>

fn split(self) -> Result<Coproduct<T>, Coproduct<Rem>>

Extract a subset of the possible types in a coproduct (or get the remaining possibilities)