Enum Either 

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

A value that is one of two possible variants: Either::Left or Either::Right.

This is a minimal, crate-local replacement for the either crate’s Either type (the external dependency was removed for dependency reduction). Only the surface actually needed by scirs2-stats is provided: construction, pattern matching, and a small set of ergonomic helpers.

Examples

use scirs2_stats::Either;

let l: Either<i32, &str> = Either::Left(7);
assert!(l.is_left());
assert_eq!(l.left(), Some(7));

let r: Either<i32, &str> = Either::Right("stats");
assert!(r.is_right());
assert_eq!(r.right(), Some("stats"));

Variants

Left(L)

The left variant.

Right(R)

The right variant.

Implementations

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

pub fn is_left(&self) -> bool

Returns true if this is the Either::Left variant.

pub fn is_right(&self) -> bool

Returns true if this is the Either::Right variant.

pub fn left(self) -> Option<L>

Consumes the value, returning the left value if present.

pub fn right(self) -> Option<R>

Consumes the value, returning the right value if present.

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

Maps the left value with f, leaving a right value untouched.

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

Maps the right value with f, leaving a left value untouched.

pub fn as_ref(&self) -> Either<&L, &R>

Converts &Either<L, R> to Either<&L, &R>.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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<L: Eq, R: Eq> Eq for Either<L, R>

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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: PartialEq, R: PartialEq> StructuralPartialEq for Either<L, R>