Enum yoke::either::EitherCart

pub enum EitherCart<C0, C1> {
    A(C0),
    B(C1),
}

A cart that can be one type or the other. Enables ergonomic polymorphic carts.

EitherCart enables yokes originating from different data sources and therefore having different cart types to be merged into the same yoke type, but still being able to recover the original cart type if necessary.

All relevant Cart traits are implemented for EitherCart, and carts can be safely wrapped in an EitherCart.

Also see Yoke::erase_box_cart().

Examples

use yoke::Yoke;
use yoke::either::EitherCart;
use std::borrow::Cow;
use std::rc::Rc;

let y1: Yoke<
    &'static str,
    Rc<str>
> = Yoke::attach_to_zero_copy_cart(
    "reference counted hello world".into()
);

let y2: Yoke<
    &'static str,
    &str
> = Yoke::attach_to_zero_copy_cart(
    "borrowed hello world"
);

type CombinedYoke<'a> = Yoke<
    &'static str,
    EitherCart<Rc<str>, &'a str>
>;

// Both yokes can be combined into a single yoke type despite different carts
let y3: CombinedYoke = y1.wrap_cart_in_either_a();
let y4: CombinedYoke = y2.wrap_cart_in_either_b();

assert_eq!(*y3.get(), "reference counted hello world");
assert_eq!(*y4.get(), "borrowed hello world");

// The resulting yoke is cloneable if both cart types implement CloneableCart
let y5 = y4.clone();
assert_eq!(*y5.get(), "borrowed hello world");

Variants

A(C0)

B(C1)

Trait Implementations

impl<C0: Clone, C1: Clone> Clone for EitherCart<C0, C1>

fn clone(&self) -> EitherCart<C0, C1>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C0, C1, T> Deref for EitherCart<C0, C1> where
    C0: Deref<Target = T>,
    C1: Deref<Target = T>, 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<C0: PartialEq, C1: PartialEq> PartialEq<EitherCart<C0, C1>> for EitherCart<C0, C1>

fn eq(&self, other: &EitherCart<C0, C1>) -> bool

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

fn ne(&self, other: &EitherCart<C0, C1>) -> bool

This method tests for !=.

impl<C0, C1> CloneableCart for EitherCart<C0, C1> where
    C0: CloneableCart,
    C1: CloneableCart, 

impl<C0: Eq, C1: Eq> Eq for EitherCart<C0, C1>

impl<C0, C1, T> StableDeref for EitherCart<C0, C1> where
    C0: StableDeref,
    C1: StableDeref,
    C0: Deref<Target = T>,
    C1: Deref<Target = T>, 

impl<C0, C1> StructuralEq for EitherCart<C0, C1>

impl<C0, C1> StructuralPartialEq for EitherCart<C0, C1>