Struct discrimination::discriminator::Sum

pub struct Sum<L, R: ?Sized> {
    pub is_right_biased: bool,
    pub left: L,
    pub right: R,
}

Fields

is_right_biased: bool

left: L

right: R

Methods

impl<L, R> Sum<L, R>

fn left_biased<A, B>(l: A, r: B) -> Sum<L, R> where
    A: Into<L>,
    B: Into<R>, 

fn right_biased<A, B>(l: A, r: B) -> Sum<L, R> where
    A: Into<L>,
    B: Into<R>, 

Trait Implementations

impl<L: Debug, R: Debug + ?Sized> Debug for Sum<L, R>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<L: Copy, R: Copy + ?Sized> Copy for Sum<L, R>

impl<L: Clone, R: Clone + ?Sized> Clone for Sum<L, R>

fn clone(&self) -> Sum<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Default, R: Default + ?Sized> Default for Sum<L, R>

fn default() -> Sum<L, R>

Returns the "default value" for a type.

impl<'a, J: 'a, K: 'a, L, R: ?Sized> Discriminator<'a, Either<J, K>> for Sum<L, R> where
    L: Discriminator<'a, J>,
    R: Discriminator<'a, K>, 

fn discriminate_sorted<V: 'a, I>(
    &'a self,
    pairs: I
) -> DiscriminateSorted<'a, Either<J, K>, V> where
    I: IntoIterator,
    I::Item: Into<(Either<J, K>, V)>,
    I::IntoIter: DoubleEndedIterator + 'a, 

fn by_ref(&'a self) -> &'a Self

fn invert(self) -> Invert<Self> where
    Self: Sized, 

fn map_key<J: 'a, F>(self, f: F) -> Map<F, Self> where
    Self: Sized,
    F: Fn(J) -> K, 

fn sum_left<J: 'a, D>(self, other: D) -> Sum<Self, D> where
    Self: Sized,
    D: Discriminator<'a, J>, 

fn sum_right<J: 'a, D>(self, other: D) -> Sum<Self, D> where
    Self: Sized,
    D: Discriminator<'a, J>, 

fn product_left<J: 'a, D>(self, other: D) -> Product<Self, D> where
    Self: Sized,
    D: Discriminator<'a, J>, 

fn product_right<J: 'a, D>(self, other: D) -> Product<Self, D> where
    Self: Sized,
    D: Discriminator<'a, J>,