Enum Among 

pub enum Among<L, M, R> {
    Left(L),
    Middle(M),
    Right(R),
}

The enum Among with variants Left, Middle and Right is a general purpose sum type with three cases.

The Among 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.

Middle(M)

A value of type M.

Right(R)

A value of type R.

Implementations

impl<L, M, R> Among<L, M, R>

pub fn try_into_left_middle(self) -> Result<Either<L, M>, R>

Available on crate feature either only.

Try to convert the Among to Either<L, M>. If the Among is Right, it will return an error.

See also into_left_middle.

Examples

use either::Either;
use among::Among;

let among: Among<i32, (), ()> = Among::Left(1);
let either = among.try_into_left_middle().unwrap();

assert_eq!(either, Either::Left(1));

let among: Among<(), i32, ()> = Among::Middle(2);
let either = among.try_into_left_middle().unwrap();

assert_eq!(either, Either::Right(2));

pub fn into_left_middle(self) -> Either<L, M>

Available on crate feature either only.

Attempts to convert the Among to Either<L, M>. If the Among is Right, it will panic.

See also try_into_left_middle.

Examples

use either::Either;
use among::Among;

let among: Among<i32, (), ()> = Among::Left(1);

let either = among.into_left_middle();

assert_eq!(either, Either::Left(1));

let among: Among<(), i32, ()> = Among::Middle(2);

let either = among.into_left_middle();

assert_eq!(either, Either::Right(2));

pub fn try_into_middle_right(self) -> Result<Either<M, R>, L>

Available on crate feature either only.

Try to convert the Among to Either<M, R>. If the Among is Left, it will return an error.

See also into_middle_right.

Examples

use either::Either;
use among::Among;

let among: Among<(), i32, ()> = Among::Middle(2);
let either = among.try_into_middle_right().unwrap();

assert_eq!(either, Either::Left(2));

let among: Among<(), (), i32> = Among::Right(3);
let either = among.try_into_middle_right().unwrap();

assert_eq!(either, Either::Right(3));

pub fn into_middle_right(self) -> Either<M, R>

Available on crate feature either only.

Attempts to convert the Among to Either<M, R>. If the Among is Left, it will panic.

See also try_into_middle_right.

Examples

use either::Either;
use among::Among;

let among: Among<(), i32, ()> = Among::Middle(2);

let either = among.into_middle_right();

assert_eq!(either, Either::Left(2));

let among: Among<(), (), i32> = Among::Right(3);

let either = among.into_middle_right();

assert_eq!(either, Either::Right(3));

pub fn try_into_left_right(self) -> Result<Either<L, R>, M>

Available on crate feature either only.

Try to convert the Among to Either<L, R>. If the Among is Middle, it will return an error.

See also into_left_right.

Examples

use either::Either;
use among::Among;


let among: Among<i32, (), i32> = Among::Left(1);
let either = among.try_into_left_right().unwrap();

assert_eq!(either, Either::Left(1));

let among: Among<(), i32, i32> = Among::Right(3);

let either = among.try_into_left_right().unwrap();

assert_eq!(either, Either::Right(3));

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

Available on crate feature either only.

Attempts to convert the Among to Either<L, R>. If the Among is Middle, it will panic.

See also try_into_left_right.

Examples

use either::Either;
use among::Among;

let among: Among<i32, (), i32> = Among::Left(1);

let either = among.into_left_right();

assert_eq!(either, Either::Left(1));

let among: Among<(), i32, i32> = Among::Right(3);

let either = among.into_left_right();

assert_eq!(either, Either::Right(3));

pub fn from_either_to_left_right(either: Either<L, R>) -> Among<L, M, R>

Available on crate feature either only.

Converts the Either<L, R> to Among<L, M, R>.

Examples

use either::Either;
use among::Among;

let either1: Either<i32, u32> = Either::Left(1);
let either2: Either<i32, u32> = Either::Right(2);

let among = Among::<i32, (), u32>::from_either_to_left_right(either1);
assert_eq!(among, Among::Left(1));

let among = Among::<i32, (), u32>::from_either_to_left_right(either2);
assert_eq!(among, Among::Right(2));

pub fn from_either_to_left_middle(either: Either<L, M>) -> Among<L, M, R>

Available on crate feature either only.

Converts the Either<L, M> to Among<L, M, R>.

Examples

use either::Either;
use among::Among;

let either1: Either<i32, u32> = Either::Left(1);
let either2: Either<i32, u32> = Either::Right(2);

let among = Among::<i32, u32, ()>::from_either_to_left_middle(either1);
assert_eq!(among, Among::Left(1));

let among = Among::<i32, u32, ()>::from_either_to_left_middle(either2);
assert_eq!(among, Among::Middle(2));

pub fn from_either_to_middle_right(either: Either<M, R>) -> Among<L, M, R>

Available on crate feature either only.

Converts the Either<M, R> to Among<L, M, R>.

Examples

use either::Either;
use among::Among;

let either1: Either<u32, i32> = Either::Left(1);
let either2: Either<u32, i32> = Either::Right(2);

let among = Among::<(), u32, i32>::from_either_to_middle_right(either1);
assert_eq!(among, Among::Middle(1));

let among = Among::<(), u32, i32>::from_either_to_middle_right(either2);
assert_eq!(among, Among::Right(2));

impl<L, M, R> Among<L, M, R>

pub fn is_left(&self) -> bool

Return true if the value is the Left variant.

use among::*;

let values = [Left(1), Middle(b"the middle value"), Right("the right value")];
assert_eq!(values[0].is_left(), true);
assert_eq!(values[1].is_left(), false);
assert_eq!(values[2].is_left(), false);

pub fn is_right(&self) -> bool

Return true if the value is the Right variant.

use among::*;

let values = [Left(1), Middle(b"the middle value"), Right("the right value")];
assert_eq!(values[0].is_right(), false);
assert_eq!(values[1].is_right(), false);
assert_eq!(values[2].is_right(), true);

pub fn is_middle(&self) -> bool

Return true if the value is the Right variant.

use among::*;

let values = [Left(1), Middle(b"the middle value"), Right("the right value")];
assert_eq!(values[0].is_middle(), false);
assert_eq!(values[1].is_middle(), true);
assert_eq!(values[2].is_middle(), false);

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

Convert the left side of Among<L, M, R> to an Option<L>.

use among::*;

let left: Among<_, i64, ()> = Left("some value");
assert_eq!(left.left(),  Some("some value"));

let right: Among<(), i64, _> = Right(321);
assert_eq!(right.left(), None);

let middle: Among<(), i64, ()> = Middle(-321);
assert_eq!(middle.left(), None);

pub fn middle(self) -> Option<M>

Convert the middle of Among<L, M, R> to an Option<M>.

use among::*;

let left: Among<_, i64, ()> = Left("some value");
assert_eq!(left.middle(),  None);

let right: Among<(), i64, _> = Right(321);
assert_eq!(right.middle(), None);

let middle: Among<(), i64, ()> = Middle(-321);
assert_eq!(middle.middle(), Some(-321));

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

Convert the right side of Among<L, M, R> to an Option<R>.

use among::*;

let left: Among<_, i64, ()> = Left("some value");
assert_eq!(left.right(),  None);

let middle: Among<(), i64, ()> = Middle(-321);
assert_eq!(middle.right(), None);

let right: Among<(), i64, _> = Right(321);
assert_eq!(right.right(), Some(321));

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

Convert &Among<L, M, R> to Among<&L, &M, &R>.

use among::*;

let left: Among<_, i64, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));

let right: Among<(), i64, _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));

let middle: Among<(), _, ()> = Middle(-321);
assert_eq!(middle.as_ref(), Middle(&-321));

pub fn as_mut(&mut self) -> Among<&mut L, &mut M, &mut R>

Convert &mut Among<L, M, R> to Among<&mut L, &mut M, &mut R>.

use among::*;

fn mutate_left(value: &mut Among<u32, u32, u32>) {
    if let Some(l) = value.as_mut().left() {
        *l = 999;
    }
}

let mut left = Left(123);
let mut middle = Middle(123);
let mut right = Right(123);

mutate_left(&mut left);
mutate_left(&mut right);
mutate_left(&mut middle);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));
assert_eq!(middle, Middle(123));

pub fn as_pin_ref(self: Pin<&Self>) -> Among<Pin<&L>, Pin<&M>, Pin<&R>>

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

pub fn as_pin_mut( self: Pin<&mut Self>, ) -> Among<Pin<&mut L>, Pin<&mut M>, Pin<&mut R>>

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

pub fn flip(self) -> Among<R, M, L>

Convert Among<L, M, R> to Among<R, M, L>.

use among::*;

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

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

pub fn map_left<F, N>(self, f: F) -> Among<N, M, R>

where F: FnOnce(L) -> N,

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

use among::*;

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

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

let middle: Among<u32, _, u32> = Middle(123);
assert_eq!(middle.map_left(|x| x * 3), Middle(123));

pub fn map_middle<F, N>(self, f: F) -> Among<L, N, R>

where F: FnOnce(M) -> N,

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

use among::*;

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

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

let middle: Among<u32, _, u32> = Middle(123);
assert_eq!(middle.map_middle(|x| x * 3), Middle(369));

pub fn map_right<F, S>(self, f: F) -> Among<L, M, S>

where F: FnOnce(R) -> S,

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

use among::*;

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

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

let middle: Among<u32, _, u32> = Middle(123);
assert_eq!(middle.map_right(|x| x * 3), Middle(123));

pub fn map_among<F, G, H, S, T, U>(self, f: F, g: G, h: H) -> Among<S, T, U>

where F: FnOnce(L) -> S, G: FnOnce(M) -> T, H: FnOnce(R) -> U,

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

use among::*;

let f = |s: String| s.len();
let h = |t: u8| t.to_string();
let g = |u: usize| u * 2;

let left: Among<String, usize, u8> = Left("loopy".into());
assert_eq!(left.map_among(f, g, h), Left(5));

let right: Among<String, usize, u8> = Right(42);
assert_eq!(right.map_among(f, g, h), Right("42".into()));

pub fn map_among_with<Ctx, F, G, H, S, T, U>( self, ctx: Ctx, f: F, g: G, h: H, ) -> Among<S, T, U>

where F: FnOnce(Ctx, L) -> S, G: FnOnce(Ctx, M) -> T, H: FnOnce(Ctx, R) -> U,

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

use among::*;

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, i: i32| { *sum += i as usize; i.to_string() };
let mut h = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };

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

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

let middle: Among<String, i32, usize> = Middle(3);
assert_eq!(middle.map_among_with(&mut sum, &mut f, &mut g, &mut h), Middle("3".into()));

assert_eq!(sum, 50);

pub fn among<F, G, H, T>(self, f: F, g: G, h: H) -> T

where F: FnOnce(L) -> T, G: FnOnce(M) -> T, H: FnOnce(R) -> T,

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

use among::*;

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

let left: Among<u32, u64, i32> = Left(4);
assert_eq!(left.among(square, cube, negate), 16);

let right: Among<u32, u64, i32> = Right(-4);
assert_eq!(right.among(square, cube, negate), 4);

let middle: Among<u32, u64, i32> = Middle(3);
assert_eq!(middle.among(square, cube, negate), 27);

pub fn among_with<Ctx, F, G, H, T>(self, ctx: Ctx, f: F, g: G, h: H) -> T

where F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, M) -> T, H: FnOnce(Ctx, R) -> T,

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

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

let mut result = Vec::new();

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

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

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

pub fn left_and_then<F, S>(self, f: F) -> Among<S, M, R>

where F: FnOnce(L) -> Among<S, M, R>,

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

use among::*;

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

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

pub fn middle_and_then<F, S>(self, f: F) -> Among<L, S, R>

where F: FnOnce(M) -> Among<L, S, R>,

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

use among::*;

let middle: Among<u32, _, u32> = Middle(123);
assert_eq!(middle.middle_and_then::<_, ()>(|x| Right(x * 2)), Right(246));

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

pub fn right_and_then<F, S>(self, f: F) -> Among<L, M, S>

where F: FnOnce(R) -> Among<L, M, S>,

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

use among::*;

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

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

pub fn into_iter(self) -> Among<L::IntoIter, M::IntoIter, R::IntoIter>

where L: IntoIterator, M: IntoIterator<Item = L::Item>, R: IntoIterator<Item = L::Item>,

Convert the inner value to an iterator.

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

use among::*;

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

pub fn iter( &self, ) -> Among<<&L as IntoIterator>::IntoIter, <&M as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where for<'a> &'a L: IntoIterator, for<'a> &'a M: IntoIterator<Item = <&'a L as IntoIterator>::Item>, for<'a> &'a R: IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Borrow the inner value as an iterator.

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

use among::*;

let left: Among<_, &[u32], &[u32]> = Left(vec![2, 3]);
let mut right: Among<Vec<u32>, &[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]);

pub fn iter_mut( &mut self, ) -> Among<<&mut L as IntoIterator>::IntoIter, <&mut M as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where for<'a> &'a mut L: IntoIterator, for<'a> &'a mut M: IntoIterator<Item = <&'a mut L as IntoIterator>::Item>, for<'a> &'a mut R: IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Mutably borrow the inner value as an iterator.

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

use among::*;

let mut left: Among<_, Vec<u32>, &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: Among<Vec<u32>, Vec<u32>, _> = Right(&mut inner[..]);
for r in right.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [16, 25]);

let mut inner = [6, 7];
let mut middle: Among<Vec<u32>, _, Vec<u32>> = Middle(&mut inner[..]);
for r in middle.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [36, 49]);

pub fn factor_into_iter( self, ) -> IterAmong<L::IntoIter, M::IntoIter, R::IntoIter>

where L: IntoIterator, M: IntoIterator, R: IntoIterator,

Converts an Among of Iterators to be an Iterator of Amongs

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

use among::*;
let left: Among<_, Box<[u8]>, Vec<u8>> = Left(&["hello"]);
assert_eq!(left.factor_into_iter().next(), Some(Left(&"hello")));

let right: Among<&[&str], Box<[u8]>, _> = Right(vec![0, 1]);
assert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);

pub fn factor_iter( &self, ) -> IterAmong<<&L as IntoIterator>::IntoIter, <&M as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where for<'a> &'a L: IntoIterator, for<'a> &'a M: IntoIterator, for<'a> &'a R: IntoIterator,

Borrows an Among of Iterators to be an Iterator of Amongs

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

use among::*;
let left: Among<_, Box<[u8]>, Vec<u8>> = Left(["hello"]);
assert_eq!(left.factor_iter().next(), Some(Left(&"hello")));

let right: Among<[&str; 2], Box<[u8]>, _> = Right(vec![0, 1]);
assert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);

pub fn factor_iter_mut( &mut self, ) -> IterAmong<<&mut L as IntoIterator>::IntoIter, <&mut M as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where for<'a> &'a mut L: IntoIterator, for<'a> &'a mut M: IntoIterator, for<'a> &'a mut R: IntoIterator,

Mutably borrows an Among of Iterators to be an Iterator of Amongs

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

use among::*;
let mut left: Among<_, Box<[u8]>, Vec<u8>> = Left(["hello"]);
left.factor_iter_mut().for_each(|x| *x.unwrap_left() = "goodbye");
assert_eq!(left, Left(["goodbye"]));

let mut right: Among<[&str; 2], Box<[u8]>, _> = 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]));

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

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: Among<&str, &str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");

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

let middle: Among<&str, &str, &str> = Middle("middle");
assert_eq!(middle.left_or("left"), "left");

pub fn left_or_default(self) -> L

where L: Default,

Return left or a default

Examples

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

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

let middle: Among<String, i32, u32> = Middle(-42);
assert_eq!(middle.left_or_default(), String::default());

pub fn left_or_else<F, G>(self, f: F, g: G) -> L

where F: FnOnce(R) -> L, G: FnOnce(M) -> L,

Returns left value or computes it from a closure

Examples

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

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

let middle: Among<String, i32, u32> = Middle(3);
assert_eq!(middle.left_or_else(|x| x.to_string(), |x| x.to_string()), "3");

pub fn middle_or(self, other: M) -> M

Return middle value or given value

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

Examples

let right: Among<&str, &str, &str> = Right("right");
assert_eq!(right.middle_or("middle"), "middle");

let left: Among<&str, &str, &str> = Left("left");
assert_eq!(left.middle_or("middle"), "middle");

let middle: Among<&str, &str, &str> = Middle("middle");
assert_eq!(middle.middle_or("foo"), "middle");

pub fn middle_or_default(self) -> M

where M: Default,

Return middle or a default

Examples

let left: Among<String, i32, u32> = Left("left".to_string());
assert_eq!(left.middle_or_default(), i32::default());

let right: Among<String, i32, u32> = Right(42);
assert_eq!(right.middle_or_default(), i32::default());

let middle: Among<String, i32, u32> = Middle(-42);
assert_eq!(middle.middle_or_default(), -42);

pub fn middle_or_else<F, G>(self, f: F, g: G) -> M

where F: FnOnce(L) -> M, G: FnOnce(R) -> M,

Returns middle value or computes it from a closure

Examples

let left: Among<String, i32, String> = Left("3".to_string());
assert_eq!(left.middle_or_else(|x| x.parse().unwrap(), |x| x.parse().unwrap()), 3);

let right: Among<String, i32, String> = Right("3".to_string());
assert_eq!(right.middle_or_else(|x| x.parse().unwrap(), |x| x.parse().unwrap()), 3);

let middle: Among<String, i32, String> = Middle(-3);
assert_eq!(middle.middle_or_else(|_| unreachable!(), |_| unreachable!()), -3);

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

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: Among<&str, &str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");

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

let middle: Among<&str, &str, &str> = Middle("middle");
assert_eq!(middle.right_or("right"), "right");

pub fn right_or_default(self) -> R

where R: Default,

Return right or a default

Examples

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

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

let middle: Among<String, i32, u32> = Middle(-42);
assert_eq!(middle.right_or_default(), u32::default());

pub fn right_or_else<F, G>(self, f: F, g: G) -> R

where F: FnOnce(L) -> R, G: FnOnce(M) -> R,

Returns right value or computes it from a closure

Examples

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

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

let middle: Among<String, &str, u32> = Middle("3");
assert_eq!(middle.right_or_else(|x| x.parse().unwrap(), |x| x.parse().unwrap()), 3);

pub fn unwrap_left(self) -> L

where M: Debug, R: Debug,

Returns the left value

Examples

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

Panics

When Among is a Right value

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

let middle: Among<(), _, ()> = Middle(3);
middle.unwrap_left();

pub fn unwrap_middle(self) -> M

where L: Debug, R: Debug,

Returns the middle value

Examples

let middle: Among<(), _, ()> = Middle(3);
assert_eq!(middle.unwrap_middle(), 3);

Panics

When Among is a Right value

let right: Among<(), (), _> = Right(3);
right.unwrap_middle();

let left: Among<_, (), ()> = Left(3);
left.unwrap_middle();

pub fn unwrap_right(self) -> R

where L: Debug, M: Debug,

Returns the right value

Examples

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

Panics

When Among is a Left value

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

let middle: Among<(), _, ()> = Middle(3);
middle.unwrap_right();

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

where M: Debug, R: Debug,

Returns the left value

Examples

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

Panics

When Among is a Right value

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

When Among is a Middle value

let middle: Among<(), _, ()> = Middle(3);
middle.expect_left("value was not Left");

pub fn expect_middle(self, msg: &str) -> M

where L: Debug, R: Debug,

Returns the left value

Examples

let middle: Among<(), _, ()> = Middle(3);
assert_eq!(middle.expect_middle("value was Middle"), 3);

Panics

When Among is a Right value

let right: Among<(), (), _> = Right(3);
right.expect_middle("value was not Middle");

When Among is a Left value

let left: Among<_, (), ()> = Left(3);
left.expect_middle("value was not Middle");

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

where L: Debug, M: Debug,

Returns the right value

Examples

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

Panics

When Among is a Left value

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

When Among is a Middle value

let middle: Among<(), _, ()> = Middle(3);
middle.expect_right("value was not Right");

pub fn among_into<T>(self) -> T

where L: Into<T>, M: Into<T>, R: Into<T>,

Convert the contained value into T

Examples

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

impl<L, M, R> Among<Option<L>, Option<M>, Option<R>>

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

Factors out None from an Among of Option.

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

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

let middle: Among<Option<Vec<u8>>, _, Option<String>> = Middle(Some(123));
assert_eq!(middle.factor_none(), Some(Middle(123)));

impl<L, M, R, E> Among<Result<L, E>, Result<M, E>, Result<R, E>>

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

Factors out a homogenous type from an Among of Result.

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

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

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

let middle: Among<Result<Vec<u8>, u32>, _, Result<String, u32>> = Middle(Ok(123));
assert_eq!(middle.factor_err(), Ok(Middle(123)));

impl<T, L, M, R> Among<Result<T, L>, Result<T, M>, Result<T, R>>

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

Factors out a homogenous type from an Among of Result.

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

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

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

let middle: Among<Result<u32, Vec<u8>>, _, Result<u32, String>> = Middle(Err(-123));
assert_eq!(middle.factor_ok(), Err(Middle(-123)));

impl<T, L, M, R> Among<(T, L), (T, M), (T, R)>

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

Factor out a homogeneous type from an among of pairs.

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

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

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

let middle: Among<(u32, Vec<u8>), _, (u32, String)> = Middle((123, vec![0]));
assert_eq!(middle.factor_first().0, 123);

impl<T, L, M, R> Among<(L, T), (M, T), (R, T)>

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

Factor out a homogeneous type from an among of pairs.

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

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

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

let middle: Among<(Vec<u8>, u32), _, (String, u32)> = Middle((-1, 123));
assert_eq!(middle.factor_second().1, 123);

impl<T> Among<T, T, T>

pub fn into_inner(self) -> T

Extract the value of an among over two equivalent types.

use among::*;

let left: Among<_, _, u32> = Left(123);
assert_eq!(left.into_inner(), 123);

let right: Among<u32, _, _> = Right(123);
assert_eq!(right.into_inner(), 123);

let middle: Among<_, u32, _> = Middle(123);
assert_eq!(middle.into_inner(), 123);

pub fn map<F, M>(self, f: F) -> Among<M, M, M>

where F: FnOnce(T) -> M,

Map f over the contained value and return the result in the corresponding variant.

use among::*;

let value: Among<_, _, i32> = Right(42);

let other = value.map(|x| x * 2);
assert_eq!(other, Right(84));

impl<L, M, R> Among<&L, &M, &R>

pub fn cloned(self) -> Among<L, M, R>

where L: Clone, M: Clone, R: Clone,

Maps an Among<&L, &M, &R> to an Among<L, M, R> by cloning the contents of among branch.

pub fn copied(self) -> Among<L, M, R>

where L: Copy, M: Copy, R: Copy,

Maps an Among<&L, &M, &R> to an Among<L, M, R> by copying the contents of among branch.

impl<L, M, R> Among<&mut L, &mut M, &mut R>

pub fn cloned(self) -> Among<L, M, R>

where L: Clone, M: Clone, R: Clone,

Maps an Among<&mut L, &mut M, &mut R> to an Among<L, M, R> by cloning the contents of among branch.

pub fn copied(self) -> Among<L, M, R>

where L: Copy, M: Copy, R: Copy,

Maps an Among<&mut L, &mut M, &mut R> to an Among<L, M, R> by copying the contents of among branch.

Trait Implementations

impl<L, M, R, Target> AsMut<[Target]> for Among<L, M, R>

where L: AsMut<[Target]>, M: AsMut<[Target]>, R: AsMut<[Target]>,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R> AsMut<CStr> for Among<L, M, R>

where L: AsMut<CStr>, M: AsMut<CStr>, R: AsMut<CStr>,

Available on crate feature std only.

Requires crate feature std.

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R> AsMut<OsStr> for Among<L, M, R>

where L: AsMut<OsStr>, M: AsMut<OsStr>, R: AsMut<OsStr>,

Available on crate feature std only.

Requires crate feature std.

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R> AsMut<Path> for Among<L, M, R>

where L: AsMut<Path>, M: AsMut<Path>, R: AsMut<Path>,

Available on crate feature std only.

Requires crate feature std.

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R, Target> AsMut<Target> for Among<L, M, R>

where L: AsMut<Target>, M: AsMut<Target>, R: AsMut<Target>,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R> AsMut<str> for Among<L, M, R>

where L: AsMut<str>, M: AsMut<str>, R: AsMut<str>,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, M, R, Target> AsRef<[Target]> for Among<L, M, R>

where L: AsRef<[Target]>, M: AsRef<[Target]>, R: AsRef<[Target]>,

fn as_ref(&self) -> &[Target]

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R> AsRef<CStr> for Among<L, M, R>

where L: AsRef<CStr>, M: AsRef<CStr>, R: AsRef<CStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R> AsRef<OsStr> for Among<L, M, R>

where L: AsRef<OsStr>, M: AsRef<OsStr>, R: AsRef<OsStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R> AsRef<Path> for Among<L, M, R>

where L: AsRef<Path>, M: AsRef<Path>, R: AsRef<Path>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R, Target> AsRef<Target> for Among<L, M, R>

where L: AsRef<Target>, M: AsRef<Target>, R: AsRef<Target>,

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R> AsRef<str> for Among<L, M, R>

where L: AsRef<str>, M: AsRef<str>, R: AsRef<str>,

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, M, R> AsyncBufRead for Among<L, M, R>

where L: AsyncBufRead, M: AsyncBufRead, R: AsyncBufRead,

Available on crate features futures-io and std only.

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<L, M, R> AsyncBufRead for Among<L, M, R>

where L: AsyncBufRead, M: AsyncBufRead, R: AsyncBufRead,

Available on crate feature tokio only.

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<L, M, R> AsyncRead for Among<L, M, R>

where L: AsyncRead, M: AsyncRead, R: AsyncRead,

Available on crate features futures-io and std only.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<L, M, R> AsyncRead for Among<L, M, R>

where L: AsyncRead, M: AsyncRead, R: AsyncRead,

Available on crate feature tokio only.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<L, M, R> AsyncSeek for Among<L, M, R>

where L: AsyncSeek, M: AsyncSeek, R: AsyncSeek,

Available on crate features futures-io and std only.

fn poll_seek( self: Pin<&mut Self>, cx: &mut Context<'_>, pos: SeekFrom, ) -> Poll<Result<u64>>

Attempt to seek to an offset, in bytes, in a stream.

impl<L, M, R> AsyncSeek for Among<L, M, R>

where L: AsyncSeek, M: AsyncSeek, R: AsyncSeek,

Available on crate feature tokio only.

fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<u64>>

Waits for a seek operation to complete.

impl<L, M, R> AsyncWrite for Among<L, M, R>

where L: AsyncWrite, M: AsyncWrite, R: AsyncWrite,

Available on crate features futures-io and std only.

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<L, M, R> AsyncWrite for Among<L, M, R>

where L: AsyncWrite, M: AsyncWrite, R: AsyncWrite,

Available on crate feature tokio only.

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<L, M, R> BufRead for Among<L, M, R>

where L: BufRead, M: BufRead, R: BufRead,

Available on crate features std only.

Requires crate feature "std"

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data, via Read methods, if empty.

fn consume(&mut self, amt: usize)

Marks the given amount of additional bytes from the internal buffer as having been read. Subsequent calls to read only return bytes that have not been marked as read.

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

Reads all bytes into buf until the delimiter byte or EOF is reached.

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

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

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

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

Checks if there is any data left to be read.

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

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

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

where Self: Sized,

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

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<L: Clone, M: Clone, R: Clone> Clone for Among<L, M, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug, M: Debug, R: Debug> Debug for Among<L, M, R>

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

Formats the value using the given formatter.

impl<L, M, R> Deref for Among<L, M, R>

where L: Deref, M: Deref<Target = L::Target>, R: Deref<Target = L::Target>,

type Target = <L as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<L, M, R> DerefMut for Among<L, M, R>

where L: DerefMut, M: DerefMut<Target = L::Target>, R: DerefMut<Target = L::Target>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, L, M, R> Deserialize<'de> for Among<L, M, R>

where L: Deserialize<'de>, M: 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<L, M, R> Display for Among<L, M, R>

where L: Display, M: Display, R: Display,

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

Formats the value using the given formatter.

impl<L, M, R> DoubleEndedIterator for Among<L, M, R>

where L: DoubleEndedIterator, M: DoubleEndedIterator<Item = L::Item>, R: DoubleEndedIterator<Item = L::Item>,

fn next_back(&mut self) -> Option<Self::Item>

Removes and returns an element from the end of the iterator.

fn nth_back(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element from the end of the iterator.

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc

where G: FnMut(Acc, Self::Item) -> Acc,

An iterator method that reduces the iterator’s elements to a single, final value, starting from the back.

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>

where P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator from the back that satisfies a predicate.

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

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

Advances the iterator from the back by n elements.

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>,

This is the reverse version of Iterator::try_fold(): it takes elements starting from the back of the iterator.

impl<L, M, R> Error for Among<L, M, R>

where L: Error, M: Error, R: Error,

Available on crate features std only.

Among implements Error if all of L, M and R implement it.

Requires crate feature "std"

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl<L, M, R> ExactSizeIterator for Among<L, M, R>

where L: ExactSizeIterator, M: ExactSizeIterator<Item = L::Item>, R: ExactSizeIterator<Item = L::Item>,

fn len(&self) -> usize

Returns the exact remaining length of the iterator.

fn is_empty(&self) -> bool

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

Returns true if the iterator is empty.

impl<L, M, R, A> Extend<A> for Among<L, M, R>

where L: Extend<A>, M: Extend<A>, R: Extend<A>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<A, B, C> From<Either<A, B>> for Among<A, B, C>

Available on crate feature either only.

fn from(either: Either<A, B>) -> Among<A, B, C>

Converts to this type from the input type.

impl<A, B, C> From<Either<A, Either<B, C>>> for Among<A, B, C>

Available on crate feature either only.

fn from(either: Either<A, Either<B, C>>) -> Among<A, B, C>

Converts to this type from the input type.

impl<A, B, C> From<Either<Either<A, B>, C>> for Among<A, B, C>

Available on crate feature either only.

fn from(either: Either<Either<A, B>, C>) -> Among<A, B, C>

Converts to this type from the input type.

impl<L, M, R> Future for Among<L, M, R>

where L: Future, M: Future, R: Future,

Among<L, M, R> is a future if both L, M and R are futures.

type Output = Among<<L as Future>::Output, <M as Future>::Output, <R as Future>::Output>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

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

impl<L: Hash, M: Hash, R: Hash> Hash for Among<L, M, 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, M, R> Iterator for Among<L, M, R>

where L: Iterator, M: Iterator<Item = L::Item>, R: Iterator<Item = L::Item>,

Among<L, M, R> is an iterator if both L and R are iterators.

type Item = <L as Iterator>::Item

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn fold<Acc, G>(self, init: Acc, f: G) -> Acc

where G: FnMut(Acc, Self::Item) -> Acc,

Folds every element into an accumulator by applying an operation, returning the final result.

fn for_each<F>(self, f: F)

where F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

Consumes the iterator, returning the last element.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>,

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn all<F>(&mut self, f: F) -> bool

where F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where P: FnMut(Self::Item) -> bool,

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

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.

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.

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.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

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

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

where Self: Sized, U: IntoIterator,

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

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

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

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

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)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

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

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

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.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

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

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

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.

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize

where T: 'a, Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool,

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

Reorders the elements of this iterator in-place according to the given predicate, such that all those that return true precede all those that return false. Returns the number of true elements found.

fn is_partitioned<P>(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.

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.

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.

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.

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.

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.

fn rposition<P>(&mut self, predicate: P) -> Option<usize>

where P: FnMut(Self::Item) -> bool, Self: Sized + ExactSizeIterator + DoubleEndedIterator,

Searches for an element in an iterator from the right, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

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.

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.

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.

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.

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedIterator,

Reverses an iterator’s direction.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

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

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

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.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

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

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<L: Ord, M: Ord, R: Ord> Ord for Among<L, M, R>

fn cmp(&self, other: &Among<L, M, R>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<L: PartialEq, M: PartialEq, R: PartialEq> PartialEq for Among<L, M, R>

fn eq(&self, other: &Among<L, M, 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: PartialOrd, M: PartialOrd, R: PartialOrd> PartialOrd for Among<L, M, R>

fn partial_cmp(&self, other: &Among<L, M, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<L, M, R> Read for Among<L, M, R>

where L: Read, M: Read, R: Read,

Available on crate features std only.

Among<L, M, R> implements Read if both L and R do.

Requires crate feature "std"

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Reads the exact number of bytes required to fill buf.

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

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

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

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

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

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

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.

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.

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

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

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

impl<L, M, R> Seek for Among<L, M, R>

where L: Seek, M: Seek, R: Seek,

Available on crate features std only.

Among<L, M, R> implements Seek if both L and R do.

Requires crate feature "std"

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

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

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

Rewind to the beginning of a stream.

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).

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

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

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

Seeks relative to the current position.

impl<L, M, R> Serialize for Among<L, M, R>

where L: Serialize, M: 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, M, R> Write for Among<L, M, R>

where L: Write, M: Write, R: Write,

Available on crate features std only.

Among<L, M, R> implements Write if all of L, M and R do.

Requires crate feature "std"

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

Writes a buffer into this writer, returning how many bytes were written.

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

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

Writes a formatted string into this writer, returning any error encountered.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

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.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

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

impl<L: Copy, M: Copy, R: Copy> Copy for Among<L, M, R>

impl<L: Eq, M: Eq, R: Eq> Eq for Among<L, M, R>

impl<L, M, R> FusedIterator for Among<L, M, R>

where L: FusedIterator, M: FusedIterator<Item = L::Item>, R: FusedIterator<Item = L::Item>,

impl<L, M, R> StructuralPartialEq for Among<L, M, R>