Enum Either

source

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

Available on crate feature __common only.

Expand description

The enum Either with variants Left and Right is a general purpose sum type with two cases.

The Either type is symmetric and treats its variants the same way, without preference. (For representing success or error, use the regular Result enum instead.)

Variants§

§

Left(L)

A value of type L.

§

Right(R)

A value of type R.

Implementations§

Convert Pin<&Either<L, R>> to Either<Pin<&L>, Pin<&R>>, pinned projections of the inner variants.

source

pub fn as_pin_mut( self: Pin<&mut Either<L, R>>, ) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ

Available on crate features __ecma and __utils only.

Convert Pin<&mut Either<L, R>> to Either<Pin<&mut L>, Pin<&mut R>>, pinned projections of the inner variants.

source

pub fn flip(self) -> Either<R, L> ⓘ

Available on crate features __ecma and __utils only.

Convert Either<L, R> to Either<R, L>.

use either::*;

let left: Either<_, ()> = Left(123);
assert_eq!(left.flip(), Right(123));

let right: Either<(), _> = Right("some value");
assert_eq!(right.flip(), Left("some value"));

source

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

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Left variant if it is present rewrapping the result in Left.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.map_left(|x| x * 2), Left(246));

let right: Either<u32, _> = Right(123);
assert_eq!(right.map_left(|x| x * 2), Right(123));

source

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

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Right variant if it is present rewrapping the result in Right.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.map_right(|x| x * 2), Left(123));

let right: Either<u32, _> = Right(123);
assert_eq!(right.map_right(|x| x * 2), Right(246));

source

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
where F: FnOnce(L) -> M, G: FnOnce(R) -> S,

Available on crate features __ecma and __utils only.

Apply the functions f and g to the Left and Right variants respectively. This is equivalent to bimap in functional programming.

use either::*;

let f = |s: String| s.len();
let g = |u: u8| u.to_string();

let left: Either<String, u8> = Left("loopy".into());
assert_eq!(left.map_either(f, g), Left(5));

let right: Either<String, u8> = Right(42);
assert_eq!(right.map_either(f, g), Right("42".into()));

source

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G, ) -> Either<M, S> ⓘ
where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

Available on crate features __ecma and __utils only.

Similar to map_either, with an added context ctx accessible to both functions.

use either::*;

let mut sum = 0;

// Both closures want to update the same value, so pass it as context.
let mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };
let mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };

let left: Either<String, usize> = Left("loopy".into());
assert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left("LOOPY".into()));

let right: Either<String, usize> = Right(42);
assert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right("42".into()));

assert_eq!(sum, 47);

source

pub fn either<F, G, T>(self, f: F, g: G) -> T
where F: FnOnce(L) -> T, G: FnOnce(R) -> T,

Available on crate features __ecma and __utils only.

Apply one of two functions depending on contents, unifying their result. If the value is Left(L) then the first function f is applied; if it is Right(R) then the second function g is applied.

use either::*;

fn square(n: u32) -> i32 { (n * n) as i32 }
fn negate(n: i32) -> i32 { -n }

let left: Either<u32, i32> = Left(4);
assert_eq!(left.either(square, negate), 16);

let right: Either<u32, i32> = Right(-4);
assert_eq!(right.either(square, negate), 4);

source

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
where F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, R) -> T,

Available on crate features __ecma and __utils only.

Like either, but provide some context to whichever of the functions ends up being called.

// In this example, the context is a mutable reference
use either::*;

let mut result = Vec::new();

let values = vec![Left(2), Right(2.7)];

for value in values {
    value.either_with(&mut result,
                      |ctx, integer| ctx.push(integer),
                      |ctx, real| ctx.push(f64::round(real) as i32));
}

assert_eq!(result, vec![2, 3]);

source

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
where F: FnOnce(L) -> Either<S, R>,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Left variant if it is present.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));

let right: Either<u32, _> = Right(123);
assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));

source

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
where F: FnOnce(R) -> Either<L, S>,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Right variant if it is present.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));

let right: Either<u32, _> = Right(123);
assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));

source

pub fn into_iter( self, ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
where L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Convert the inner value to an iterator.

This requires the Left and Right iterators to have the same item type. See factor_into_iter to iterate different types.

use either::*;

let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
let mut right: Either<Vec<u32>, _> = Right(vec![]);
right.extend(left.into_iter());
assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));

source

pub fn iter( &self, ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘ
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter to iterate different types.

use either::*;

let left: Either<_, &[u32]> = Left(vec![2, 3]);
let mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);
let mut all = vec![1];
all.extend(left.iter());
all.extend(right.iter());
assert_eq!(all, vec![1, 2, 3, 4, 5]);

source

pub fn iter_mut( &mut self, ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘ
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Mutably borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter_mut to iterate different types.

use either::*;

let mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);
for l in left.iter_mut() {
    *l *= *l
}
assert_eq!(left, Left(vec![4, 9]));

let mut inner = [4, 5];
let mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);
for r in right.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [16, 25]);

source

pub fn factor_into_iter( self, ) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>
where L: IntoIterator, R: IntoIterator,

Available on crate features __ecma and __utils only.

Converts an Either of Iterators to be an Iterator of Eithers

Unlike into_iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(&["hello"]);
assert_eq!(left.factor_into_iter().next(), Some(Left(&"hello")));
let right: Either<&[&str], _> = Right(vec![0, 1]);
assert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);

source

pub fn factor_iter( &self, ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

Available on crate features __ecma and __utils only.

Borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(["hello"]);
assert_eq!(left.factor_iter().next(), Some(Left(&"hello")));
let right: Either<[&str; 2], _> = Right(vec![0, 1]);
assert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);

source

pub fn factor_iter_mut( &mut self, ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

Available on crate features __ecma and __utils only.

Mutably borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter_mut, this does not require the Left and Right iterators to have the same item type.

use either::*;
let mut left: Either<_, Vec<u8>> = Left(["hello"]);
left.factor_iter_mut().for_each(|x| *x.unwrap_left() = "goodbye");
assert_eq!(left, Left(["goodbye"]));
let mut right: Either<[&str; 2], _> = Right(vec![0, 1, 2]);
right.factor_iter_mut().for_each(|x| if let Right(r) = x { *r = -*r; });
assert_eq!(right, Right(vec![0, -1, -2]));

source

pub fn left_or(self, other: L) -> L

Available on crate features __ecma and __utils only.

Return left value or given value

Arguments passed to left_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use left_or_else, which is lazily evaluated.

§Examples

let left: Either<&str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");

let right: Either<&str, &str> = Right("right");
assert_eq!(right.left_or("left"), "left");

source

pub fn left_or_default(self) -> L
where L: Default,

Available on crate features __ecma and __utils only.

Return left or a default

§Examples

let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.left_or_default(), "left");

let right: Either<String, u32> = Right(42);
assert_eq!(right.left_or_default(), String::default());

source

pub fn left_or_else<F>(self, f: F) -> L
where F: FnOnce(R) -> L,

Available on crate features __ecma and __utils only.

Returns left value or computes it from a closure

§Examples

let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.left_or_else(|_| unreachable!()), "3");

let right: Either<String, u32> = Right(3);
assert_eq!(right.left_or_else(|x| x.to_string()), "3");

source

pub fn right_or(self, other: R) -> R

Available on crate features __ecma and __utils only.

Return right value or given value

Arguments passed to right_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use right_or_else, which is lazily evaluated.

§Examples

let right: Either<&str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");

let left: Either<&str, &str> = Left("left");
assert_eq!(left.right_or("right"), "right");

source

pub fn right_or_default(self) -> R
where R: Default,

Available on crate features __ecma and __utils only.

Return right or a default

§Examples

let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.right_or_default(), u32::default());

let right: Either<String, u32> = Right(42);
assert_eq!(right.right_or_default(), 42);

source

pub fn right_or_else<F>(self, f: F) -> R
where F: FnOnce(L) -> R,

Available on crate features __ecma and __utils only.

Returns right value or computes it from a closure

§Examples

let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);

let right: Either<String, u32> = Right(3);
assert_eq!(right.right_or_else(|_| unreachable!()), 3);

source

pub fn unwrap_left(self) -> L
where R: Debug,

Available on crate features __ecma and __utils only.

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);
assert_eq!(left.unwrap_left(), 3);

§Panics

When Either is a Right value

let right: Either<(), _> = Right(3);
right.unwrap_left();

source

pub fn unwrap_right(self) -> R
where L: Debug,

Available on crate features __ecma and __utils only.

Returns the right value

§Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.unwrap_right(), 3);

§Panics

When Either is a Left value

let left: Either<_, ()> = Left(3);
left.unwrap_right();

source

pub fn expect_left(self, msg: &str) -> L
where R: Debug,

Available on crate features __ecma and __utils only.

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);
assert_eq!(left.expect_left("value was Right"), 3);

§Panics

When Either is a Right value

let right: Either<(), _> = Right(3);
right.expect_left("value was Right");

source

pub fn expect_right(self, msg: &str) -> R
where L: Debug,

Available on crate features __ecma and __utils only.

Returns the right value

§Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.expect_right("value was Left"), 3);

§Panics

When Either is a Left value

let left: Either<_, ()> = Left(3);
left.expect_right("value was Right");

source

pub fn either_into<T>(self) -> T
where L: Into<T>, R: Into<T>,

Available on crate features __ecma and __utils only.

Convert the contained value into T

§Examples

// Both u16 and u32 can be converted to u64.
let left: Either<u16, u32> = Left(3u16);
assert_eq!(left.either_into::<u64>(), 3u64);
let right: Either<u16, u32> = Right(7u32);
assert_eq!(right.either_into::<u64>(), 7u64);

source §

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

source

pub fn factor_none(self) -> Option<Either<L, R>>

Available on crate features __ecma and __utils only.

Factors out None from an Either of Option.

use either::*;
let left: Either<_, Option<String>> = Left(Some(vec![0]));
assert_eq!(left.factor_none(), Some(Left(vec![0])));

let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
assert_eq!(right.factor_none(), Some(Right(String::new())));

source §

impl<L, R, E> Either<Result<L, E>, Result<R, E>>

source

pub fn factor_err(self) -> Result<Either<L, R>, E>

Available on crate features __ecma and __utils only.

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Err type of the Result.

use either::*;
let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
assert_eq!(left.factor_err(), Ok(Left(vec![0])));

let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
assert_eq!(right.factor_err(), Ok(Right(String::new())));

source §

impl<T, L, R> Either<Result<T, L>, Result<T, R>>

source

pub fn factor_ok(self) -> Result<T, Either<L, R>>

Available on crate features __ecma and __utils only.

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Ok type of the Result.

use either::*;
let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
assert_eq!(left.factor_ok(), Err(Left(vec![0])));

let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
assert_eq!(right.factor_ok(), Err(Right(String::new())));

source §

impl<T, L, R> Either<(T, L), (T, R)>

source

pub fn factor_first(self) -> (T, Either<L, R>)

Available on crate features __ecma and __utils only.

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the first element of the pairs.

use either::*;
let left: Either<_, (u32, String)> = Left((123, vec![0]));
assert_eq!(left.factor_first().0, 123);

let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
assert_eq!(right.factor_first().0, 123);

source §

impl<T, L, R> Either<(L, T), (R, T)>

source

pub fn factor_second(self) -> (Either<L, R>, T)

Available on crate features __ecma and __utils only.

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the second element of the pairs.

use either::*;
let left: Either<_, (String, u32)> = Left((vec![0], 123));
assert_eq!(left.factor_second().1, 123);

let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
assert_eq!(right.factor_second().1, 123);

pub fn cloned(self) -> Either<L, R> ⓘ
where L: Clone, R: Clone,

Available on crate features __ecma and __utils only.

Maps an Either<&L, &R> to an Either<L, R> by cloning the contents of either branch.

source

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

Available on crate features __ecma and __utils only.

Maps an Either<&L, &R> to an Either<L, R> by copying the contents of either branch.

source §

impl<L, R> Either<&mut L, &mut R>

source

pub fn cloned(self) -> Either<L, R> ⓘ
where L: Clone, R: Clone,

Available on crate features __ecma and __utils only.

Maps an Either<&mut L, &mut R> to an Either<L, R> by cloning the contents of either branch.

source

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

Available on crate features __ecma and __utils only.

Maps an Either<&mut L, &mut R> to an Either<L, R> by copying the contents of either branch.

Trait Implementations§

source §

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached. Read more

1.0.0 · source§

fn split(self, byte: u8) -> Split<Self>
where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte. Read more

1.0.0 · source§

fn lines(self) -> Lines<Self>
where Self: Sized,

Returns an iterator over the lines of this reader. Read more

source §

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

source §

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

Returns a copy of the value. Read more

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements. Read more

§

§

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

source §

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

source §

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

Feeds this value into the given Hasher. Read more

1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more

§

Searches for an element in an iterator, returning its index. Read more

source §

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values. Read more

source §

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements. Read more

1.28.0 · source§

fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more

1.0.0 · source§

fn chain(self, other: U) -> Chain<Self, ::IntoIter>
where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more

1.0.0 · source§

fn zip(self, other: U) -> Zip<Self, ::IntoIter>
where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs. Read more

source §

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

fn fuse(self) -> Fuse<Self>
where Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more

1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Borrows an iterator, rather than consuming it. Read more

source §

fn collect_into<E>(self, collection: &mut E) -> &mut E
where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection. Read more

source §

fn is_partitioned(self, predicate: P) -> bool
where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false. Read more

1.27.0 · source§

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more

1.27.0 · source§

fn try_for_each<F, R>(&mut self, f: F) -> R
where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more

1.51.0 · source§

fn reduce<F>(self, f: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more

source §

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. Read more

source §

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error. Read more

1.6.0 · source§

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function. Read more

1.15.0 · source§

fn max_by<F>(self, compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function. Read more

1.6.0 · source§

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function. Read more

1.15.0 · source§

fn min_by<F>(self, compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function. Read more

1.0.0 · source§

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where FromA: Default + Extend<A>, FromB: Default + Extend, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers. Read more

1.36.0 · source§

fn copied<'a, T>(self) -> Copied<Self>
where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements. Read more

1.0.0 · source§

fn cloned<'a, T>(self) -> Cloned<Self>
where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements. Read more

source §

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time. Read more

1.11.0 · source§

source §

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

source §

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

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

1.0.0 · source§

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

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

source §

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf. Read more

source §

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf. Read more

source §

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf. Read more

1.36.0 · source§

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers. Read more

source §

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation. Read more

source §

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer. Read more

source §

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream. Read more

1.55.0 · source§

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream. Read more

source §

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes). Read more

1.51.0 · source§

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream. Read more

1.80.0 · source§

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position. Read more

§

Visit a node of type YieldExpr. Read more

§

Visit a node of type WqName. Read more

§

source §

impl<L, R> Write for Either<L, R>
where L: Write, R: Write,

Either<L, R> implements Write if both L and R do.

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation. Read more

source §

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer. Read more

1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adapter for this instance of Write. Read more

source §

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

source §

impl<L, R> Eq for Either<L, R>
where L: Eq, R: Eq,

source §

impl<L, R> FusedIterator for Either<L, R>
where L: FusedIterator, R: FusedIterator<Item = <L as Iterator>::Item>,

source §

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

§

fn try_as_bits<O>(&self) -> Result<&BitSlice<T, O>, BitSpanError<T>>
where O: BitOrder,

Attempts to view self as an immutable bit-slice region with the O ordering. Read more

§

impl<A, T> AsMutBits<T> for A
where A: AsMut<[T]>, T: BitStore,

§

fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘ
where O: BitOrder,

Views self as a mutable bit-slice region with the O ordering.

impl<T> From<T> for T

source §

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<It> IdentifyLast for It
where It: Iterator,

§

fn identify_last(self) -> Iter<It> ⓘ

source §

impl<T> ImplicitClone for T
where T: Clone,

source §

fn clone_quote_var(&self) -> Self

Available on crate feature ecma_quote only.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

👎Deprecated since 0.13.0: Use .chunk_by() instead

fn tree_reduce<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

Accumulate the elements in the iterator in a tree-like manner. Read more

§

fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

👎Deprecated since 0.13.0: Use .tree_reduce() instead

Apply a runtime-determined style

§

impl<T, P> Parse<Box<T>> for P
where P: Parse<T>,

§

fn parse(&mut self) -> Result<Box<T>, Error>

§

fn read_f64_into<T>(&mut self, dst: &mut [f64]) -> Result<(), Error>
where T: ByteOrder,

Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader. Read more

§

fn read_f64_into_unchecked<T>(&mut self, dst: &mut [f64]) -> Result<(), Error>
where T: ByteOrder,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

source §

impl<T> ToHex for T
where T: AsRef<[u8]>,

source §

fn encode_hex(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

source §

fn encode_hex_upper(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

source §

impl<T> ToOwned for T
where T: Clone,

source §

type Owned = T

The resulting type after obtaining ownership.

source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Writes a IEEE754 double-precision (8 bytes) floating point number to the underlying writer. Read more

§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeSendSync for T

source §

impl<N> NodeTrait for N
where N: Copy + Ord + Hash,

§

Enum EitherCopy item path

Variants§

Left(L)

Right(R)

Implementations§

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

pub fn is_left(&self) -> bool

pub fn is_right(&self) -> bool

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

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

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

pub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ

pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ

pub fn as_pin_mut( self: Pin<&mut Either<L, R>>, ) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ

pub fn flip(self) -> Either<R, L> ⓘ

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

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

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘwhere F: FnOnce(L) -> M, G: FnOnce(R) -> S,

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G, ) -> Either<M, S> ⓘwhere F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

pub fn either<F, G, T>(self, f: F, g: G) -> Twhere F: FnOnce(L) -> T, G: FnOnce(R) -> T,

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> Twhere F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, R) -> T,

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘwhere F: FnOnce(L) -> Either<S, R>,

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘwhere F: FnOnce(R) -> Either<L, S>,

pub fn into_iter( self, ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘwhere L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

pub fn iter( &self, ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘwhere &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

pub fn iter_mut( &mut self, ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘwhere &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

pub fn factor_into_iter( self, ) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>where L: IntoIterator, R: IntoIterator,

pub fn factor_iter( &self, ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

pub fn factor_iter_mut( &mut self, ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

pub fn left_or(self, other: L) -> L

§Examples

pub fn left_or_default(self) -> Lwhere L: Default,

§Examples

pub fn left_or_else<F>(self, f: F) -> Lwhere F: FnOnce(R) -> L,

§Examples

pub fn right_or(self, other: R) -> R

§Examples

pub fn right_or_default(self) -> Rwhere R: Default,

§Examples

pub fn right_or_else<F>(self, f: F) -> Rwhere F: FnOnce(L) -> R,

§Examples

pub fn unwrap_left(self) -> Lwhere R: Debug,

§Examples

§Panics

pub fn unwrap_right(self) -> Rwhere L: Debug,

§Examples

§Panics

pub fn expect_left(self, msg: &str) -> Lwhere R: Debug,

§Examples

§Panics

pub fn expect_right(self, msg: &str) -> Rwhere L: Debug,

§Examples

§Panics

pub fn either_into<T>(self) -> Twhere L: Into<T>, R: Into<T>,

§Examples

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

pub fn factor_none(self) -> Option<Either<L, R>>

impl<L, R, E> Either<Result<L, E>, Result<R, E>>

pub fn factor_err(self) -> Result<Either<L, R>, E>

impl<T, L, R> Either<Result<T, L>, Result<T, R>>

pub fn factor_ok(self) -> Result<T, Either<L, R>>

impl<T, L, R> Either<(T, L), (T, R)>

pub fn factor_first(self) -> (T, Either<L, R>)

impl<T, L, R> Either<(L, T), (R, T)>

pub fn factor_second(self) -> (Either<L, R>, T)

impl<T> Either<T, T>

pub fn into_inner(self) -> T

pub fn map<F, M>(self, f: F) -> Either<M, M> ⓘwhere F: FnOnce(T) -> M,

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

pub fn cloned(self) -> Either<L, R> ⓘwhere L: Clone, R: Clone,

pub fn copied(self) -> Either<L, R> ⓘwhere L: Copy, R: Copy,

impl<L, R> Either<&mut L, &mut R>

pub fn cloned(self) -> Either<L, R> ⓘwhere L: Clone, R: Clone,

pub fn copied(self) -> Either<L, R> ⓘwhere L: Copy, R: Copy,

Trait Implementations§

impl<L, R, Target> AsMut<[Target]> for Either<L, R>where L: AsMut<[Target]>, R: AsMut<[Target]>,

fn as_mut(&mut self) -> &mut [Target]

impl<L, R> AsMut<CStr> for Either<L, R>where L: AsMut<CStr>, R: AsMut<CStr>,

fn as_mut(&mut self) -> &mut CStr

impl<L, R> AsMut<OsStr> for Either<L, R>where L: AsMut<OsStr>, R: AsMut<OsStr>,

Enum Either

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

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

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
where F: FnOnce(L) -> M, G: FnOnce(R) -> S,

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G, ) -> Either<M, S> ⓘ
where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

pub fn either<F, G, T>(self, f: F, g: G) -> T
where F: FnOnce(L) -> T, G: FnOnce(R) -> T,

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
where F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, R) -> T,

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
where F: FnOnce(L) -> Either<S, R>,

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
where F: FnOnce(R) -> Either<L, S>,

pub fn into_iter( self, ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
where L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

pub fn iter( &self, ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘ
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

pub fn iter_mut( &mut self, ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘ
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

pub fn factor_into_iter( self, ) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>
where L: IntoIterator, R: IntoIterator,

pub fn factor_iter( &self, ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

pub fn factor_iter_mut( &mut self, ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

pub fn left_or_default(self) -> L
where L: Default,

pub fn left_or_else<F>(self, f: F) -> L
where F: FnOnce(R) -> L,

pub fn right_or_default(self) -> R
where R: Default,

pub fn right_or_else<F>(self, f: F) -> R
where F: FnOnce(L) -> R,

pub fn unwrap_left(self) -> L
where R: Debug,

pub fn unwrap_right(self) -> R
where L: Debug,

pub fn expect_left(self, msg: &str) -> L
where R: Debug,

pub fn expect_right(self, msg: &str) -> R
where L: Debug,

pub fn either_into<T>(self) -> T
where L: Into<T>, R: Into<T>,

pub fn map<F, M>(self, f: F) -> Either<M, M> ⓘ
where F: FnOnce(T) -> M,

pub fn cloned(self) -> Either<L, R> ⓘ
where L: Clone, R: Clone,

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

pub fn cloned(self) -> Either<L, R> ⓘ
where L: Clone, R: Clone,

pub fn copied(self) -> Either<L, R> ⓘ
where L: Copy, R: Copy,

impl<L, R, Target> AsMut<[Target]> for Either<L, R>
where L: AsMut<[Target]>, R: AsMut<[Target]>,

impl<L, R> AsMut<CStr> for Either<L, R>
where L: AsMut<CStr>, R: AsMut<CStr>,

impl<L, R> AsMut<OsStr> for Either<L, R>
where L: AsMut<OsStr>, R: AsMut<OsStr>,

impl<L, R> AsMut<Path> for Either<L, R>
where L: AsMut<Path>, R: AsMut<Path>,

impl<L, R, Target> AsMut<Target> for Either<L, R>
where L: AsMut<Target>, R: AsMut<Target>,

impl<L, R> AsMut<str> for Either<L, R>
where L: AsMut<str>, R: AsMut<str>,

impl<L, R, Target> AsRef<[Target]> for Either<L, R>
where L: AsRef<[Target]>, R: AsRef<[Target]>,

impl<L, R> AsRef<CStr> for Either<L, R>
where L: AsRef<CStr>, R: AsRef<CStr>,

impl<L, R> AsRef<OsStr> for Either<L, R>
where L: AsRef<OsStr>, R: AsRef<OsStr>,

impl<L, R> AsRef<Path> for Either<L, R>
where L: AsRef<Path>, R: AsRef<Path>,

impl<L, R, Target> AsRef<Target> for Either<L, R>
where L: AsRef<Target>, R: AsRef<Target>,

impl<L, R> AsRef<str> for Either<L, R>
where L: AsRef<str>, R: AsRef<str>,

impl<L, R> BufRead for Either<L, R>
where L: BufRead, R: BufRead,

fn split(self, byte: u8) -> Split<Self>
where Self: Sized,

fn lines(self) -> Lines<Self>
where Self: Sized,

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

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

impl<L, R> Deref for Either<L, R>
where L: Deref, R: Deref<Target = <L as Deref>::Target>,

impl<L, R> DerefMut for Either<L, R>
where L: DerefMut, R: DerefMut<Target = <L as Deref>::Target>,

impl<L, R> Display for Either<L, R>
where L: Display, R: Display,

impl<L, R> DoubleEndedIterator for Either<L, R>
where L: DoubleEndedIterator, R: DoubleEndedIterator<Item = <L as Iterator>::Item>,

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
where G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
where P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

impl<L, R> Error for Either<L, R>
where L: Error, R: Error,

impl<L, R> ExactSizeIterator for Either<L, R>
where L: ExactSizeIterator, R: ExactSizeIterator<Item = <L as Iterator>::Item>,

impl<L, R, A> Extend<A> for Either<L, R>
where L: Extend<A>, R: Extend<A>,

fn extend<T>(&mut self, iter: T)
where T: IntoIterator<Item = A>,

impl<A, B> Fold for Either<A, B>
where A: Fold, B: Fold,