Enum Either 

pub enum Either<L, R> {
    Left(L),
    Right(R),
}

Variants

Left(L)

Right(R)

Implementations

impl<L, R> Either<L, R>

pub fn map_left<LL, F: FnOnce(L) -> LL>(self, f: F) -> Either<LL, R>

pub fn map_right<RR, F: FnOnce(R) -> RR>(self, f: F) -> Either<L, RR>

Trait Implementations

impl<L: Debug, R: Debug> Debug for Either<L, R>

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

Formats the value using the given formatter.

impl<'de, L, R> Deserialize<'de> for Either<L, R>

where L: Deserialize<'de>, R: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, L, R> FromBorrowedStr<'a> for Either<L, R>

where L: FromBorrowedStr<'a>, R: FromBorrowedStr<'a>,

type Err = (<L as FromBorrowedStr<'a>>::Err, <R as FromBorrowedStr<'a>>::Err)

fn from_borrowed_str(s: &'a str) -> Result<Self, Self::Err>

impl<L, R> FromSqlRow for Either<L, R>

where L: FromSqlRow, R: FromSqlRow,

type Out = Either<<L as FromSqlRow>::Out, <R as FromSqlRow>::Out>

fn from_sql_row( &mut self, row: &Row<'_>, idx: &mut ColumnIndex, ) -> Result<Self::Out>

fn from_start_of_row(&mut self, row: &Row<'_>) -> Result<Self::Out>

impl<L: PartialEq, R: PartialEq> PartialEq for Either<L, R>

fn eq(&self, other: &Either<L, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<L, R> Serialize for Either<L, R>

where L: Serialize, R: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L, R> StructuralPartialEq for Either<L, R>