Lines Matching defs:Either
1 //! The enum [`Either`] with variants `Left` and `Right` is a general purpose
4 //! [`Either`]: enum.Either.html
12 //! Disabled by default. Enable to `#[derive(Serialize, Deserialize)]` for `Either`
40 pub use crate::Either::{Left, Right};
42 /// The enum `Either` with variants `Left` and `Right` is a general purpose
45 /// The `Either` type is symmetric and treats its variants the same way, without
50 pub enum Either<L, R> {
57 /// Evaluate the provided expression for both [`Either::Left`] and [`Either::Right`].
59 /// This macro is useful in cases where both sides of [`Either`] can be interacted with
67 /// use either::Either;
69 /// fn length(owned_or_borrowed: Either<String, &'static str>) -> usize {
74 /// let borrowed = Either::Right("Hello world!");
75 /// let owned = Either::Left("Hello world!".to_owned());
85 $crate::Either::Left($pattern) => $result,
86 $crate::Either::Right($pattern) => $result,
91 /// Macro for unwrapping the left side of an `Either`, which fails early
93 /// `Either` because of the early return of `Right` that it provides.
101 /// use either::{Either, Left, Right};
103 /// fn twice(wrapper: Either<u32, &str>) -> Either<u32, &str> {
134 impl<L: Clone, R: Clone> Clone for Either<L, R> {
151 impl<L, R> Either<L, R> {
181 /// Convert the left side of `Either<L, R>` to an `Option<L>`.
186 /// let left: Either<_, ()> = Left("some value");
189 /// let right: Either<(), _> = Right(321);
199 /// Convert the right side of `Either<L, R>` to an `Option<R>`.
204 /// let left: Either<_, ()> = Left("some value");
207 /// let right: Either<(), _> = Right(321);
217 /// Convert `&Either<L, R>` to `Either<&L, &R>`.
222 /// let left: Either<_, ()> = Left("some value");
225 /// let right: Either<(), _> = Right("some value");
228 pub fn as_ref(&self) -> Either<&L, &R> {
235 /// Convert `&mut Either<L, R>` to `Either<&mut L, &mut R>`.
240 /// fn mutate_left(value: &mut Either<u32, u32>) {
253 pub fn as_mut(&mut self) -> Either<&mut L, &mut R> {
260 /// Convert `Pin<&Either<L, R>>` to `Either<Pin<&L>, Pin<&R>>`,
262 pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&L>, Pin<&R>> {
273 /// Convert `Pin<&mut Either<L, R>>` to `Either<Pin<&mut L>, Pin<&mut R>>`,
275 pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut L>, Pin<&mut R>> {
289 /// Convert `Either<L, R>` to `Either<R, L>`.
294 /// let left: Either<_, ()> = Left(123);
297 /// let right: Either<(), _> = Right("some value");
300 pub fn flip(self) -> Either<R, L> {
313 /// let left: Either<_, u32> = Left(123);
316 /// let right: Either<u32, _> = Right(123);
319 pub fn map_left<F, M>(self, f: F) -> Either<M, R>
335 /// let left: Either<_, u32> = Left(123);
338 /// let right: Either<u32, _> = Right(123);
341 pub fn map_right<F, S>(self, f: F) -> Either<L, S>
361 /// let left: Either<u32, i32> = Left(4);
364 /// let right: Either<u32, i32> = Right(-4);
413 /// let left: Either<_, u32> = Left(123);
416 /// let right: Either<u32, _> = Right(123);
419 pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>
421 F: FnOnce(L) -> Either<S, R>,
434 /// let left: Either<_, u32> = Left(123);
437 /// let right: Either<u32, _> = Right(123);
440 pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>
442 F: FnOnce(R) -> Either<L, S>,
455 /// let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
456 /// let mut right: Either<Vec<u32>, _> = Right(vec![]);
461 pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter>
484 /// let left: Either<&str, &str> = Left("left");
487 /// let right: Either<&str, &str> = Right("right");
492 Either::Left(l) => l,
493 Either::Right(_) => other,
503 /// let left: Either<String, u32> = Left("left".to_string());
506 /// let right: Either<String, u32> = Right(42);
514 Either::Left(l) => l,
515 Either::Right(_) => L::default(),
525 /// let left: Either<String, u32> = Left("3".to_string());
528 /// let right: Either<String, u32> = Right(3);
536 Either::Left(l) => l,
537 Either::Right(r) => f(r),
553 /// let right: Either<&str, &str> = Right("right");
556 /// let left: Either<&str, &str> = Left("left");
561 Either::Left(_) => other,
562 Either::Right(r) => r,
572 /// let left: Either<String, u32> = Left("left".to_string());
575 /// let right: Either<String, u32> = Right(42);
583 Either::Left(_) => R::default(),
584 Either::Right(r) => r,
594 /// let left: Either<String, u32> = Left("3".to_string());
597 /// let right: Either<String, u32> = Right(3);
605 Either::Left(l) => f(l),
606 Either::Right(r) => r,
616 /// let left: Either<_, ()> = Left(3);
622 /// When `Either` is a `Right` value
626 /// let right: Either<(), _> = Right(3);
634 Either::Left(l) => l,
635 Either::Right(r) => {
636 panic!("called `Either::unwrap_left()` on a `Right` value: {:?}", r)
647 /// let right: Either<(), _> = Right(3);
653 /// When `Either` is a `Left` value
657 /// let left: Either<_, ()> = Left(3);
665 Either::Right(r) => r,
666 Either::Left(l) => panic!("called `Either::unwrap_right()` on a `Left` value: {:?}", l),
676 /// let left: Either<_, ()> = Left(3);
682 /// When `Either` is a `Right` value
686 /// let right: Either<(), _> = Right(3);
694 Either::Left(l) => l,
695 Either::Right(r) => panic!("{}: {:?}", msg, r),
705 /// let right: Either<(), _> = Right(3);
711 /// When `Either` is a `Left` value
715 /// let left: Either<_, ()> = Left(3);
723 Either::Right(r) => r,
724 Either::Left(l) => panic!("{}: {:?}", msg, l),
735 /// let left: Either<u16, u32> = Left(3u16);
737 /// let right: Either<u16, u32> = Right(7u32);
746 Either::Left(l) => l.into(),
747 Either::Right(r) => r.into(),
752 impl<L, R> Either<Option<L>, Option<R>> {
753 /// Factors out `None` from an `Either` of [`Option`].
757 /// let left: Either<_, Option<String>> = Left(Some(vec![0]));
760 /// let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
765 pub fn factor_none(self) -> Option<Either<L, R>> {
767 Left(l) => l.map(Either::Left),
768 Right(r) => r.map(Either::Right),
773 impl<L, R, E> Either<Result<L, E>, Result<R, E>> {
774 /// Factors out a homogenous type from an `Either` of [`Result`].
780 /// let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
783 /// let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
788 pub fn factor_err(self) -> Result<Either<L, R>, E> {
790 Left(l) => l.map(Either::Left),
791 Right(r) => r.map(Either::Right),
796 impl<T, L, R> Either<Result<T, L>, Result<T, R>> {
797 /// Factors out a homogenous type from an `Either` of [`Result`].
803 /// let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
806 /// let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
811 pub fn factor_ok(self) -> Result<T, Either<L, R>> {
813 Left(l) => l.map_err(Either::Left),
814 Right(r) => r.map_err(Either::Right),
819 impl<T, L, R> Either<(T, L), (T, R)> {
826 /// let left: Either<_, (u32, String)> = Left((123, vec![0]));
829 /// let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
832 pub fn factor_first(self) -> (T, Either<L, R>) {
840 impl<T, L, R> Either<(L, T), (R, T)> {
847 /// let left: Either<_, (String, u32)> = Left((vec![0], 123));
850 /// let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
853 pub fn factor_second(self) -> (Either<L, R>, T) {
861 impl<T> Either<T, T> {
867 /// let left: Either<_, u32> = Left(123);
870 /// let right: Either<u32, _> = Right(123);
883 /// let value: Either<_, i32> = Right(42);
888 pub fn map<F, M>(self, f: F) -> Either<M, M>
899 /// Convert from `Result` to `Either` with `Ok => Right` and `Err => Left`.
900 impl<L, R> From<Result<R, L>> for Either<L, R> {
909 /// Convert from `Either` to `Result` with `Right => Ok` and `Left => Err`.
911 impl<L, R> Into<Result<R, L>> for Either<L, R> {
920 impl<L, R, A> Extend<A> for Either<L, R>
933 /// `Either<L, R>` is an iterator if both `L` and `R` are iterators.
934 impl<L, R> Iterator for Either<L, R>
1026 impl<L, R> DoubleEndedIterator for Either<L, R>
1055 impl<L, R> ExactSizeIterator for Either<L, R>
1065 impl<L, R> iter::FusedIterator for Either<L, R>
1072 /// `Either<L, R>` is a future if both `L` and `R` are futures.
1073 impl<L, R> Future for Either<L, R>
1089 /// `Either<L, R>` implements `Read` if both `L` and `R` do.
1092 impl<L, R> Read for Either<L, R>
1115 /// `Either<L, R>` implements `Seek` if both `L` and `R` do.
1118 impl<L, R> Seek for Either<L, R>
1130 impl<L, R> BufRead for Either<L, R>
1153 /// `Either<L, R>` implements `Write` if both `L` and `R` do.
1156 impl<L, R> Write for Either<L, R>
1178 impl<L, R, Target> AsRef<Target> for Either<L, R>
1191 impl<L, R> AsRef<$t> for Either<L, R>
1200 impl<L, R> AsMut<$t> for Either<L, R>
1227 impl<L, R, Target> AsRef<[Target]> for Either<L, R>
1237 impl<L, R, Target> AsMut<Target> for Either<L, R>
1247 impl<L, R, Target> AsMut<[Target]> for Either<L, R>
1257 impl<L, R> Deref for Either<L, R>
1269 impl<L, R> DerefMut for Either<L, R>
1280 /// `Either` implements `Error` if *both* `L` and `R` implement it.
1281 impl<L, R> Error for Either<L, R>
1301 impl<L, R> fmt::Display for Either<L, R>
1328 fn a() -> Either<u32, u32> {
1334 fn b() -> Either<String, &'static str> {
1345 let value: Either<String, &str> = Left(String::from("test"));
1440 check_ref::<Either<T1, T2>>()
1444 check_mut::<Either<T1, T2>>()
1457 check_array_ref::<Either<T1, T2>, _>()
1461 check_array_mut::<Either<T1, T2>, _>()