Lines Matching full: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`
15 #![doc(html_root_url = "https://docs.rs/either/1/")]
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> { enum
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
62 /// Syntax: `either::for_both!(` *expression* `,` *pattern* `=>` *expression* `)`
67 /// use either::Either;
69 /// fn length(owned_or_borrowed: Either<String, &'static str>) -> usize {
70 /// either::for_both!(owned_or_borrowed, s => s.len())
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> {
104 /// let value = either::try_left!(wrapper);
134 impl<L: Clone, R: Clone> Clone for Either<L, R> { implementation
151 impl<L, R> Either<L, R> { implementation
155 /// use either::*;
171 /// use either::*;
181 /// Convert the left side of `Either<L, R>` to an `Option<L>`.
184 /// use either::*;
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>`.
202 /// use either::*;
204 /// let left: Either<_, ()> = Left("some value");
207 /// let right: Either<(), _> = Right(321);
217 /// Convert `&Either<L, R>` to `Either<&L, &R>`.
220 /// use either::*;
222 /// let left: Either<_, ()> = Left("some value");
225 /// let right: Either<(), _> = Right("some value");
228 pub fn as_ref(&self) -> Either<&L, &R> { in as_ref()
235 /// Convert `&mut Either<L, R>` to `Either<&mut L, &mut R>`.
238 /// use either::*;
240 /// fn mutate_left(value: &mut Either<u32, u32>) {
253 pub fn as_mut(&mut self) -> Either<&mut L, &mut R> { in as_mut()
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>> { in as_pin_ref()
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>> { in as_pin_mut()
289 /// Convert `Either<L, R>` to `Either<R, L>`.
292 /// use either::*;
294 /// let left: Either<_, ()> = Left(123);
297 /// let right: Either<(), _> = Right("some value");
300 pub fn flip(self) -> Either<R, L> { in flip()
311 /// use either::*;
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> in map_left()
333 /// use either::*;
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> in map_right()
357 /// use either::*;
362 /// let left: Either<String, u8> = Left("loopy".into());
365 /// let right: Either<String, u8> = Right(42);
368 pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> in map_either()
383 /// use either::*;
391 /// let left: Either<String, usize> = Left("loopy".into());
394 /// let right: Either<String, usize> = Right(42);
399 pub fn map_either_with<Ctx, F, G, M, S>(self, ctx: Ctx, f: F, g: G) -> Either<M, S> in map_either_with()
415 /// use either::*;
420 /// let left: Either<u32, i32> = Left(4);
421 /// assert_eq!(left.either(square, negate), 16);
423 /// let right: Either<u32, i32> = Right(-4);
424 /// assert_eq!(right.either(square, negate), 4);
426 pub fn either<F, G, T>(self, f: F, g: G) -> T in either() method
437 /// Like `either`, but provide some context to whichever of the
442 /// use either::*;
470 /// use either::*;
472 /// let left: Either<_, u32> = Left(123);
475 /// let right: Either<u32, _> = Right(123);
478 pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> in left_and_then()
480 F: FnOnce(L) -> Either<S, R>, in left_and_then()
491 /// use either::*;
493 /// let left: Either<_, u32> = Left(123);
496 /// let right: Either<u32, _> = Right(123);
499 pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> in right_and_then()
501 F: FnOnce(R) -> Either<L, S>, in right_and_then()
512 /// use either::*;
514 /// let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
515 /// let mut right: Either<Vec<u32>, _> = Right(vec![]);
520 pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter> in into_iter()
542 /// # use either::*;
543 /// let left: Either<&str, &str> = Left("left");
546 /// let right: Either<&str, &str> = Right("right");
551 Either::Left(l) => l, in left_or()
552 Either::Right(_) => other, in left_or()
561 /// # use either::*;
562 /// let left: Either<String, u32> = Left("left".to_string());
565 /// let right: Either<String, u32> = Right(42);
573 Either::Left(l) => l, in left_or_default()
574 Either::Right(_) => L::default(), in left_or_default()
583 /// # use either::*;
584 /// let left: Either<String, u32> = Left("3".to_string());
587 /// let right: Either<String, u32> = Right(3);
595 Either::Left(l) => l, in left_or_else()
596 Either::Right(r) => f(r), in left_or_else()
611 /// # use either::*;
612 /// let right: Either<&str, &str> = Right("right");
615 /// let left: Either<&str, &str> = Left("left");
620 Either::Left(_) => other, in right_or()
621 Either::Right(r) => r, in right_or()
630 /// # use either::*;
631 /// let left: Either<String, u32> = Left("left".to_string());
634 /// let right: Either<String, u32> = Right(42);
642 Either::Left(_) => R::default(), in right_or_default()
643 Either::Right(r) => r, in right_or_default()
652 /// # use either::*;
653 /// let left: Either<String, u32> = Left("3".to_string());
656 /// let right: Either<String, u32> = Right(3);
664 Either::Left(l) => f(l), in right_or_else()
665 Either::Right(r) => r, in right_or_else()
674 /// # use either::*;
675 /// let left: Either<_, ()> = Left(3);
681 /// When `Either` is a `Right` value
684 /// # use either::*;
685 /// let right: Either<(), _> = Right(3);
693 Either::Left(l) => l, in unwrap_left()
694 Either::Right(r) => { in unwrap_left()
695 panic!("called `Either::unwrap_left()` on a `Right` value: {:?}", r) in unwrap_left()
705 /// # use either::*;
706 /// let right: Either<(), _> = Right(3);
712 /// When `Either` is a `Left` value
715 /// # use either::*;
716 /// let left: Either<_, ()> = Left(3);
724 Either::Right(r) => r, in unwrap_right()
725 Either::Left(l) => panic!("called `Either::unwrap_right()` on a `Left` value: {:?}", l), in unwrap_right()
734 /// # use either::*;
735 /// let left: Either<_, ()> = Left(3);
741 /// When `Either` is a `Right` value
744 /// # use either::*;
745 /// let right: Either<(), _> = Right(3);
753 Either::Left(l) => l, in expect_left()
754 Either::Right(r) => panic!("{}: {:?}", msg, r), in expect_left()
763 /// # use either::*;
764 /// let right: Either<(), _> = Right(3);
770 /// When `Either` is a `Left` value
773 /// # use either::*;
774 /// let left: Either<_, ()> = Left(3);
782 Either::Right(r) => r, in expect_right()
783 Either::Left(l) => panic!("{}: {:?}", msg, l), in expect_right()
792 /// # use either::*;
794 /// let left: Either<u16, u32> = Left(3u16);
796 /// let right: Either<u16, u32> = Right(7u32);
805 Either::Left(l) => l.into(), in either_into()
806 Either::Right(r) => r.into(), in either_into()
811 impl<L, R> Either<Option<L>, Option<R>> { implementation
812 /// Factors out `None` from an `Either` of [`Option`].
815 /// use either::*;
816 /// let left: Either<_, Option<String>> = Left(Some(vec![0]));
819 /// let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
824 pub fn factor_none(self) -> Option<Either<L, R>> { in factor_none()
826 Left(l) => l.map(Either::Left), in factor_none()
827 Right(r) => r.map(Either::Right), in factor_none()
832 impl<L, R, E> Either<Result<L, E>, Result<R, E>> { impl
833 /// Factors out a homogenous type from an `Either` of [`Result`].
838 /// use either::*;
839 /// let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
842 /// let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
847 pub fn factor_err(self) -> Result<Either<L, R>, E> { in factor_err()
849 Left(l) => l.map(Either::Left), in factor_err()
850 Right(r) => r.map(Either::Right), in factor_err()
855 impl<T, L, R> Either<Result<T, L>, Result<T, R>> { implementation
856 /// Factors out a homogenous type from an `Either` of [`Result`].
861 /// use either::*;
862 /// let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
865 /// let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
870 pub fn factor_ok(self) -> Result<T, Either<L, R>> { in factor_ok()
872 Left(l) => l.map_err(Either::Left), in factor_ok()
873 Right(r) => r.map_err(Either::Right), in factor_ok()
878 impl<T, L, R> Either<(T, L), (T, R)> { impl
879 /// Factor out a homogeneous type from an either of pairs.
884 /// use either::*;
885 /// let left: Either<_, (u32, String)> = Left((123, vec![0]));
888 /// let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
891 pub fn factor_first(self) -> (T, Either<L, R>) { in factor_first()
899 impl<T, L, R> Either<(L, T), (R, T)> { implementation
900 /// Factor out a homogeneous type from an either of pairs.
905 /// use either::*;
906 /// let left: Either<_, (String, u32)> = Left((vec![0], 123));
909 /// let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
912 pub fn factor_second(self) -> (Either<L, R>, T) { in factor_second()
920 impl<T> Either<T, T> { implementation
921 /// Extract the value of an either over two equivalent types.
924 /// use either::*;
926 /// let left: Either<_, u32> = Left(123);
929 /// let right: Either<u32, _> = Right(123);
940 /// use either::*;
942 /// let value: Either<_, i32> = Right(42);
947 pub fn map<F, M>(self, f: F) -> Either<M, M> in map()
958 /// Convert from `Result` to `Either` with `Ok => Right` and `Err => Left`.
959 impl<L, R> From<Result<R, L>> for Either<L, R> { implementation
968 /// Convert from `Either` to `Result` with `Right => Ok` and `Left => Err`.
970 impl<L, R> Into<Result<R, L>> for Either<L, R> { implementation
979 impl<L, R, A> Extend<A> for Either<L, R> implementation
992 /// `Either<L, R>` is an iterator if both `L` and `R` are iterators.
993 impl<L, R> Iterator for Either<L, R> implementation
1085 impl<L, R> DoubleEndedIterator for Either<L, R> implementation
1114 impl<L, R> ExactSizeIterator for Either<L, R> implementation
1124 impl<L, R> iter::FusedIterator for Either<L, R> implementation
1131 /// `Either<L, R>` is a future if both `L` and `R` are futures.
1132 impl<L, R> Future for Either<L, R> implementation
1148 /// `Either<L, R>` implements `Read` if both `L` and `R` do.
1151 impl<L, R> Read for Either<L, R> implementation
1174 /// `Either<L, R>` implements `Seek` if both `L` and `R` do.
1177 impl<L, R> Seek for Either<L, R> implementation
1189 impl<L, R> BufRead for Either<L, R> implementation
1212 /// `Either<L, R>` implements `Write` if both `L` and `R` do.
1215 impl<L, R> Write for Either<L, R> implementation
1237 impl<L, R, Target> AsRef<Target> for Either<L, R> implementation
1250 impl<L, R> AsRef<$t> for Either<L, R>
1259 impl<L, R> AsMut<$t> for Either<L, R>
1286 impl<L, R, Target> AsRef<[Target]> for Either<L, R> implementation
1296 impl<L, R, Target> AsMut<Target> for Either<L, R> implementation
1306 impl<L, R, Target> AsMut<[Target]> for Either<L, R> implementation
1316 impl<L, R> Deref for Either<L, R> implementation
1328 impl<L, R> DerefMut for Either<L, R> implementation
1339 /// `Either` implements `Error` if *both* `L` and `R` implement it.
1340 impl<L, R> Error for Either<L, R> implementation
1360 impl<L, R> fmt::Display for Either<L, R> implementation
1387 fn a() -> Either<u32, u32> { in macros()
1393 fn b() -> Either<String, &'static str> { in macros()
1404 let value: Either<String, &str> = Left(String::from("test")); in deref()
1499 check_ref::<Either<T1, T2>>()
1503 check_mut::<Either<T1, T2>>()
1516 check_array_ref::<Either<T1, T2>, _>() in _unsized_ref_propagation()
1520 check_array_mut::<Either<T1, T2>, _>() in _unsized_ref_propagation()