Lines Matching refs:Left
1 //! The enum [`Either`] with variants `Left` and `Right` is a general purpose
40 pub use crate::Either::{Left, Right};
42 /// The enum `Either` with variants `Left` and `Right` is a general purpose
52 Left(L),
57 /// Evaluate the provided expression for both [`Either::Left`] and [`Either::Right`].
75 /// let owned = Either::Left("Hello world!".to_owned());
85 $crate::Either::Left($pattern) => $result,
101 /// use either::{Either, Left, Right};
105 /// Left(value * 2)
109 /// assert_eq!(twice(Left(2)), Left(4));
117 $crate::Left(val) => val,
128 $crate::Left(err) => return $crate::Left(::core::convert::From::from(err)),
137 Left(inner) => Left(inner.clone()),
144 (Left(dest), Left(source)) => dest.clone_from(source),
152 /// Return true if the value is the `Left` variant.
157 /// let values = [Left(1), Right("the right value")];
163 Left(_) => true,
173 /// let values = [Left(1), Right("the right value")];
186 /// let left: Either<_, ()> = Left("some value");
194 Left(l) => Some(l),
204 /// let left: Either<_, ()> = Left("some value");
212 Left(_) => None,
222 /// let left: Either<_, ()> = Left("some value");
223 /// assert_eq!(left.as_ref(), Left(&"some value"));
230 Left(ref inner) => Left(inner),
246 /// let mut left = Left(123);
250 /// assert_eq!(left, Left(999));
255 Left(ref mut inner) => Left(inner),
267 Left(ref inner) => Left(Pin::new_unchecked(inner)),
283 Left(ref mut inner) => Left(Pin::new_unchecked(inner)),
294 /// let left: Either<_, ()> = Left(123);
298 /// assert_eq!(right.flip(), Left("some value"));
302 Left(l) => Right(l),
303 Right(r) => Left(r),
307 /// Apply the function `f` on the value in the `Left` variant if it is present rewrapping the
308 /// result in `Left`.
313 /// let left: Either<_, u32> = Left(123);
314 /// assert_eq!(left.map_left(|x| x * 2), Left(246));
324 Left(l) => Left(f(l)),
335 /// let left: Either<_, u32> = Left(123);
336 /// assert_eq!(left.map_right(|x| x * 2), Left(123));
346 Left(l) => Left(l),
352 /// `Left(L)` then the first function `f` is applied; if it is `Right(R)` then the second
361 /// let left: Either<u32, i32> = Left(4);
373 Left(l) => f(l),
387 /// let values = vec![Left(2), Right(2.7)];
403 Left(l) => f(ctx, l),
408 /// Apply the function `f` on the value in the `Left` variant if it is present.
413 /// let left: Either<_, u32> = Left(123);
424 Left(l) => f(l),
434 /// let left: Either<_, u32> = Left(123);
435 /// assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));
445 Left(l) => Left(l),
455 /// let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
467 Left(l) => Left(l.into_iter()),
484 /// let left: Either<&str, &str> = Left("left");
492 Either::Left(l) => l,
503 /// let left: Either<String, u32> = Left("left".to_string());
514 Either::Left(l) => l,
525 /// let left: Either<String, u32> = Left("3".to_string());
536 Either::Left(l) => l,
556 /// let left: Either<&str, &str> = Left("left");
561 Either::Left(_) => other,
572 /// let left: Either<String, u32> = Left("left".to_string());
583 Either::Left(_) => R::default(),
594 /// let left: Either<String, u32> = Left("3".to_string());
605 Either::Left(l) => f(l),
616 /// let left: Either<_, ()> = Left(3);
634 Either::Left(l) => l,
653 /// When `Either` is a `Left` value
657 /// let left: Either<_, ()> = Left(3);
666 Either::Left(l) => panic!("called `Either::unwrap_right()` on a `Left` value: {:?}", l),
676 /// let left: Either<_, ()> = Left(3);
694 Either::Left(l) => l,
706 /// assert_eq!(right.expect_right("value was Left"), 3);
711 /// When `Either` is a `Left` value
715 /// let left: Either<_, ()> = Left(3);
724 Either::Left(l) => panic!("{}: {:?}", msg, l),
735 /// let left: Either<u16, u32> = Left(3u16);
746 Either::Left(l) => l.into(),
757 /// let left: Either<_, Option<String>> = Left(Some(vec![0]));
758 /// assert_eq!(left.factor_none(), Some(Left(vec![0])));
767 Left(l) => l.map(Either::Left),
780 /// let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
781 /// assert_eq!(left.factor_err(), Ok(Left(vec![0])));
790 Left(l) => l.map(Either::Left),
803 /// let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
804 /// assert_eq!(left.factor_ok(), Err(Left(vec![0])));
813 Left(l) => l.map_err(Either::Left),
826 /// let left: Either<_, (u32, String)> = Left((123, vec![0]));
834 Left((t, l)) => (t, Left(l)),
847 /// let left: Either<_, (String, u32)> = Left((vec![0], 123));
855 Left((l, t)) => (Left(l), t),
867 /// let left: Either<_, u32> = Left(123);
893 Left(l) => Left(f(l)),
899 /// Convert from `Result` to `Either` with `Ok => Right` and `Err => Left`.
903 Err(e) => Left(e),
909 /// Convert from `Either` to `Result` with `Right => Ok` and `Left => Err`.
914 Left(l) => Err(l),
1313 let mut e = Left(2);
1315 assert_eq!(e, Left(2));
1330 Left(x * 2)
1335 Right(try_right!(Left("foo bar")))
1337 assert_eq!(b(), Left(String::from("foo bar")));
1345 let value: Either<String, &str> = Left(String::from("test"));
1353 3 => Left(0..10),
1373 Left(io::Cursor::new([]))
1400 Left(io::stdin())
1411 Left(io::stdout())
1425 Err(Left(error))