Initial import of either-1.6.1. am: d767123c85
Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/either/+/1621403
Change-Id: Id654b3d41a378fbbd8b07e921e333e27d6af4060
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
new file mode 100644
index 0000000..1a91ec1
--- /dev/null
+++ b/.cargo_vcs_info.json
@@ -0,0 +1,5 @@
+{
+ "git": {
+ "sha1": "6d3216446d4828d9fa254a6952b40408fbc9c9bd"
+ }
+}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4fffb2f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/target
+/Cargo.lock
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..f3a3024
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,33 @@
+language: rust
+sudo: false
+
+# run builds for all the trains (and more)
+rust:
+ - stable
+ - beta
+ - nightly
+
+branches:
+ only:
+ - master
+# the main build
+script:
+ - |
+ cargo build --features "${FEATURES}" &&
+ cargo test --features "${FEATURES}" &&
+ cargo doc --features "${FEATURES}"
+
+env:
+ matrix:
+ - FEATURES=""
+ - FEATURES="serde"
+
+matrix:
+ include:
+ - rust: 1.12.0
+ env: FEATURES=""
+ before_script:
+ - |
+ cargo generate-lockfile &&
+ cargo update -p serde_json --precise 1.0.0 &&
+ cargo update -p serde --precise 1.0.0
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..ccf747b
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,39 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "either"
+version = "1.6.1"
+authors = ["bluss"]
+description = "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.\n"
+documentation = "https://docs.rs/either/1/"
+readme = "README-crates.io.md"
+keywords = ["data-structure", "no_std"]
+categories = ["data-structures", "no-std"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/bluss/either"
+[package.metadata.docs.rs]
+features = ["serde"]
+
+[package.metadata.release]
+no-dev-version = true
+tag-name = "{{version}}"
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+optional = true
+[dev-dependencies.serde_json]
+version = "1.0.0"
+
+[features]
+default = ["use_std"]
+use_std = []
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
new file mode 100644
index 0000000..5797caf
--- /dev/null
+++ b/Cargo.toml.orig
@@ -0,0 +1,33 @@
+[package]
+name = "either"
+version = "1.6.1"
+authors = ["bluss"]
+
+license = "MIT/Apache-2.0"
+repository = "https://github.com/bluss/either"
+documentation = "https://docs.rs/either/1/"
+readme = "README-crates.io.md"
+
+description = """
+The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
+"""
+
+keywords = ["data-structure", "no_std"]
+categories = ["data-structures", "no-std"]
+
+[dependencies]
+serde = { version = "1.0", optional = true, features = ["derive"] }
+
+[features]
+default = ["use_std"]
+use_std = []
+
+[dev-dependencies]
+serde_json = "1.0.0"
+
+[package.metadata.release]
+no-dev-version = true
+tag-name = "{{version}}"
+
+[package.metadata.docs.rs]
+features = ["serde"]
diff --git a/README-crates.io.md b/README-crates.io.md
new file mode 100644
index 0000000..d368902
--- /dev/null
+++ b/README-crates.io.md
@@ -0,0 +1,10 @@
+The enum `Either` with variants `Left` and `Right` is a general purpose
+sum type with two cases.
+
+Either has methods that are similar to Option and Result, and it also implements
+traits like `Iterator`.
+
+Includes macros `try_left!()` and `try_right!()` to use for
+short-circuiting logic, similar to how the `?` operator is used with `Result`.
+Note that `Either` is general purpose. For describing success or error, use the
+regular `Result`.
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..38d3920
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,129 @@
+
+Either
+======
+
+The enum ``Either`` with variants ``Left`` and ``Right`` and trait
+implementations including Iterator, Read, Write.
+
+Either has methods that are similar to Option and Result.
+
+Includes convenience macros ``try_left!()`` and ``try_right!()`` to use for
+short-circuiting logic.
+
+Please read the `API documentation here`__
+
+__ https://docs.rs/either/
+
+|build_status|_ |crates|_
+
+.. |build_status| image:: https://travis-ci.org/bluss/either.svg?branch=master
+.. _build_status: https://travis-ci.org/bluss/either
+
+.. |crates| image:: http://meritbadge.herokuapp.com/either
+.. _crates: https://crates.io/crates/either
+
+How to use with cargo::
+
+ [dependencies]
+ either = "1.6"
+
+
+Recent Changes
+--------------
+
+- 1.6.1
+
+ - Add new methods ``.expect_left()``, ``.unwrap_left()``,
+ and equivalents on the right, by @spenserblack (#51)
+
+- 1.6.0
+
+ - Add new modules ``serde_untagged`` and ``serde_untagged_optional`` to customize
+ how ``Either`` fields are serialized in other types, by @MikailBag (#49)
+
+- 1.5.3
+
+ - Add new method ``.map()`` for ``Either<T, T>`` by @nvzqz (#40).
+
+- 1.5.2
+
+ - Add new methods ``.left_or()``, ``.left_or_default()``, ``.left_or_else()``,
+ and equivalents on the right, by @DCjanus (#36)
+
+- 1.5.1
+
+ - Add ``AsRef`` and ``AsMut`` implementations for common unsized types:
+ ``str``, ``[T]``, ``CStr``, ``OsStr``, and ``Path``, by @mexus (#29)
+
+- 1.5.0
+
+ - Add new methods ``.factor_first()``, ``.factor_second()`` and ``.into_inner()``
+ by @mathstuf (#19)
+
+- 1.4.0
+
+ - Add inherent method ``.into_iter()`` by @cuviper (#12)
+
+- 1.3.0
+
+ - Add opt-in serde support by @hcpl
+
+- 1.2.0
+
+ - Add method ``.either_with()`` by @Twey (#13)
+
+- 1.1.0
+
+ - Add methods ``left_and_then``, ``right_and_then`` by @rampantmonkey
+ - Include license files in the repository and released crate
+
+- 1.0.3
+
+ - Add crate categories
+
+- 1.0.2
+
+ - Forward more ``Iterator`` methods
+ - Implement ``Extend`` for ``Either<L, R>`` if ``L, R`` do.
+
+- 1.0.1
+
+ - Fix ``Iterator`` impl for ``Either`` to forward ``.fold()``.
+
+- 1.0.0
+
+ - Add default crate feature ``use_std`` so that you can opt out of linking to
+ std.
+
+- 0.1.7
+
+ - Add methods ``.map_left()``, ``.map_right()`` and ``.either()``.
+ - Add more documentation
+
+- 0.1.3
+
+ - Implement Display, Error
+
+- 0.1.2
+
+ - Add macros ``try_left!`` and ``try_right!``.
+
+- 0.1.1
+
+ - Implement Deref, DerefMut
+
+- 0.1.0
+
+ - Initial release
+ - Support Iterator, Read, Write
+
+License
+-------
+
+Dual-licensed to be compatible with the Rust project.
+
+Licensed under the Apache License, Version 2.0
+http://www.apache.org/licenses/LICENSE-2.0 or the MIT license
+http://opensource.org/licenses/MIT, at your
+option. This file may not be copied, modified, or distributed
+except according to those terms.
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..3ef249f
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1146 @@
+//! The enum [`Either`] with variants `Left` and `Right` is a general purpose
+//! sum type with two cases.
+//!
+//! [`Either`]: enum.Either.html
+//!
+//! **Crate features:**
+//!
+//! * `"use_std"`
+//! Enabled by default. Disable to make the library `#![no_std]`.
+//!
+//! * `"serde"`
+//! Disabled by default. Enable to `#[derive(Serialize, Deserialize)]` for `Either`
+//!
+
+#![doc(html_root_url = "https://docs.rs/either/1/")]
+#![cfg_attr(all(not(test), not(feature = "use_std")), no_std)]
+#[cfg(all(not(test), not(feature = "use_std")))]
+extern crate core as std;
+
+#[cfg(feature = "serde")]
+#[macro_use]
+extern crate serde;
+
+#[cfg(feature = "serde")]
+pub mod serde_untagged;
+
+#[cfg(feature = "serde")]
+pub mod serde_untagged_optional;
+
+use std::convert::{AsMut, AsRef};
+use std::fmt;
+use std::iter;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+#[cfg(any(test, feature = "use_std"))]
+use std::error::Error;
+#[cfg(any(test, feature = "use_std"))]
+use std::io::{self, BufRead, Read, Write};
+
+pub use Either::{Left, Right};
+
+/// The enum `Either` with variants `Left` and `Right` is a general purpose
+/// sum type with two cases.
+///
+/// The `Either` type is symmetric and treats its variants the same way, without
+/// preference.
+/// (For representing success or error, use the regular `Result` enum instead.)
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Either<L, R> {
+ /// A value of type `L`.
+ Left(L),
+ /// A value of type `R`.
+ Right(R),
+}
+
+macro_rules! either {
+ ($value:expr, $pattern:pat => $result:expr) => {
+ match $value {
+ Either::Left($pattern) => $result,
+ Either::Right($pattern) => $result,
+ }
+ };
+}
+
+/// Macro for unwrapping the left side of an `Either`, which fails early
+/// with the opposite side. Can only be used in functions that return
+/// `Either` because of the early return of `Right` that it provides.
+///
+/// See also `try_right!` for its dual, which applies the same just to the
+/// right side.
+///
+/// # Example
+///
+/// ```
+/// #[macro_use] extern crate either;
+/// use either::{Either, Left, Right};
+///
+/// fn twice(wrapper: Either<u32, &str>) -> Either<u32, &str> {
+/// let value = try_left!(wrapper);
+/// Left(value * 2)
+/// }
+///
+/// fn main() {
+/// assert_eq!(twice(Left(2)), Left(4));
+/// assert_eq!(twice(Right("ups")), Right("ups"));
+/// }
+/// ```
+#[macro_export]
+macro_rules! try_left {
+ ($expr:expr) => {
+ match $expr {
+ $crate::Left(val) => val,
+ $crate::Right(err) => return $crate::Right(::std::convert::From::from(err)),
+ }
+ };
+}
+
+/// Dual to `try_left!`, see its documentation for more information.
+#[macro_export]
+macro_rules! try_right {
+ ($expr:expr) => {
+ match $expr {
+ $crate::Left(err) => return $crate::Left(::std::convert::From::from(err)),
+ $crate::Right(val) => val,
+ }
+ };
+}
+
+impl<L, R> Either<L, R> {
+ /// Return true if the value is the `Left` variant.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let values = [Left(1), Right("the right value")];
+ /// assert_eq!(values[0].is_left(), true);
+ /// assert_eq!(values[1].is_left(), false);
+ /// ```
+ pub fn is_left(&self) -> bool {
+ match *self {
+ Left(_) => true,
+ Right(_) => false,
+ }
+ }
+
+ /// Return true if the value is the `Right` variant.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let values = [Left(1), Right("the right value")];
+ /// assert_eq!(values[0].is_right(), false);
+ /// assert_eq!(values[1].is_right(), true);
+ /// ```
+ pub fn is_right(&self) -> bool {
+ !self.is_left()
+ }
+
+ /// Convert the left side of `Either<L, R>` to an `Option<L>`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, ()> = Left("some value");
+ /// assert_eq!(left.left(), Some("some value"));
+ ///
+ /// let right: Either<(), _> = Right(321);
+ /// assert_eq!(right.left(), None);
+ /// ```
+ pub fn left(self) -> Option<L> {
+ match self {
+ Left(l) => Some(l),
+ Right(_) => None,
+ }
+ }
+
+ /// Convert the right side of `Either<L, R>` to an `Option<R>`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, ()> = Left("some value");
+ /// assert_eq!(left.right(), None);
+ ///
+ /// let right: Either<(), _> = Right(321);
+ /// assert_eq!(right.right(), Some(321));
+ /// ```
+ pub fn right(self) -> Option<R> {
+ match self {
+ Left(_) => None,
+ Right(r) => Some(r),
+ }
+ }
+
+ /// Convert `&Either<L, R>` to `Either<&L, &R>`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, ()> = Left("some value");
+ /// assert_eq!(left.as_ref(), Left(&"some value"));
+ ///
+ /// let right: Either<(), _> = Right("some value");
+ /// assert_eq!(right.as_ref(), Right(&"some value"));
+ /// ```
+ pub fn as_ref(&self) -> Either<&L, &R> {
+ match *self {
+ Left(ref inner) => Left(inner),
+ Right(ref inner) => Right(inner),
+ }
+ }
+
+ /// Convert `&mut Either<L, R>` to `Either<&mut L, &mut R>`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// fn mutate_left(value: &mut Either<u32, u32>) {
+ /// if let Some(l) = value.as_mut().left() {
+ /// *l = 999;
+ /// }
+ /// }
+ ///
+ /// let mut left = Left(123);
+ /// let mut right = Right(123);
+ /// mutate_left(&mut left);
+ /// mutate_left(&mut right);
+ /// assert_eq!(left, Left(999));
+ /// assert_eq!(right, Right(123));
+ /// ```
+ pub fn as_mut(&mut self) -> Either<&mut L, &mut R> {
+ match *self {
+ Left(ref mut inner) => Left(inner),
+ Right(ref mut inner) => Right(inner),
+ }
+ }
+
+ /// Convert `Either<L, R>` to `Either<R, L>`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, ()> = Left(123);
+ /// assert_eq!(left.flip(), Right(123));
+ ///
+ /// let right: Either<(), _> = Right("some value");
+ /// assert_eq!(right.flip(), Left("some value"));
+ /// ```
+ pub fn flip(self) -> Either<R, L> {
+ match self {
+ Left(l) => Right(l),
+ Right(r) => Left(r),
+ }
+ }
+
+ /// Apply the function `f` on the value in the `Left` variant if it is present rewrapping the
+ /// result in `Left`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, u32> = Left(123);
+ /// assert_eq!(left.map_left(|x| x * 2), Left(246));
+ ///
+ /// let right: Either<u32, _> = Right(123);
+ /// assert_eq!(right.map_left(|x| x * 2), Right(123));
+ /// ```
+ pub fn map_left<F, M>(self, f: F) -> Either<M, R>
+ where
+ F: FnOnce(L) -> M,
+ {
+ match self {
+ Left(l) => Left(f(l)),
+ Right(r) => Right(r),
+ }
+ }
+
+ /// Apply the function `f` on the value in the `Right` variant if it is present rewrapping the
+ /// result in `Right`.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, u32> = Left(123);
+ /// assert_eq!(left.map_right(|x| x * 2), Left(123));
+ ///
+ /// let right: Either<u32, _> = Right(123);
+ /// assert_eq!(right.map_right(|x| x * 2), Right(246));
+ /// ```
+ pub fn map_right<F, S>(self, f: F) -> Either<L, S>
+ where
+ F: FnOnce(R) -> S,
+ {
+ match self {
+ Left(l) => Left(l),
+ Right(r) => Right(f(r)),
+ }
+ }
+
+ /// Apply one of two functions depending on contents, unifying their result. If the value is
+ /// `Left(L)` then the first function `f` is applied; if it is `Right(R)` then the second
+ /// function `g` is applied.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// fn square(n: u32) -> i32 { (n * n) as i32 }
+ /// fn negate(n: i32) -> i32 { -n }
+ ///
+ /// let left: Either<u32, i32> = Left(4);
+ /// assert_eq!(left.either(square, negate), 16);
+ ///
+ /// let right: Either<u32, i32> = Right(-4);
+ /// assert_eq!(right.either(square, negate), 4);
+ /// ```
+ pub fn either<F, G, T>(self, f: F, g: G) -> T
+ where
+ F: FnOnce(L) -> T,
+ G: FnOnce(R) -> T,
+ {
+ match self {
+ Left(l) => f(l),
+ Right(r) => g(r),
+ }
+ }
+
+ /// Like `either`, but provide some context to whichever of the
+ /// functions ends up being called.
+ ///
+ /// ```
+ /// // In this example, the context is a mutable reference
+ /// use either::*;
+ ///
+ /// let mut result = Vec::new();
+ ///
+ /// let values = vec![Left(2), Right(2.7)];
+ ///
+ /// for value in values {
+ /// value.either_with(&mut result,
+ /// |ctx, integer| ctx.push(integer),
+ /// |ctx, real| ctx.push(f64::round(real) as i32));
+ /// }
+ ///
+ /// assert_eq!(result, vec![2, 3]);
+ /// ```
+ pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
+ where
+ F: FnOnce(Ctx, L) -> T,
+ G: FnOnce(Ctx, R) -> T,
+ {
+ match self {
+ Left(l) => f(ctx, l),
+ Right(r) => g(ctx, r),
+ }
+ }
+
+ /// Apply the function `f` on the value in the `Left` variant if it is present.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, u32> = Left(123);
+ /// assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));
+ ///
+ /// let right: Either<u32, _> = Right(123);
+ /// assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
+ /// ```
+ pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>
+ where
+ F: FnOnce(L) -> Either<S, R>,
+ {
+ match self {
+ Left(l) => f(l),
+ Right(r) => Right(r),
+ }
+ }
+
+ /// Apply the function `f` on the value in the `Right` variant if it is present.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, u32> = Left(123);
+ /// assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));
+ ///
+ /// let right: Either<u32, _> = Right(123);
+ /// assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
+ /// ```
+ pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>
+ where
+ F: FnOnce(R) -> Either<L, S>,
+ {
+ match self {
+ Left(l) => Left(l),
+ Right(r) => f(r),
+ }
+ }
+
+ /// Convert the inner value to an iterator.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
+ /// let mut right: Either<Vec<u32>, _> = Right(vec![]);
+ /// right.extend(left.into_iter());
+ /// assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));
+ /// ```
+ pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter>
+ where
+ L: IntoIterator,
+ R: IntoIterator<Item = L::Item>,
+ {
+ match self {
+ Left(l) => Left(l.into_iter()),
+ Right(r) => Right(r.into_iter()),
+ }
+ }
+
+ /// 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.
+ ///
+ /// [`left_or_else`]: #method.left_or_else
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<&str, &str> = Left("left");
+ /// assert_eq!(left.left_or("foo"), "left");
+ ///
+ /// let right: Either<&str, &str> = Right("right");
+ /// assert_eq!(right.left_or("left"), "left");
+ /// ```
+ pub fn left_or(self, other: L) -> L {
+ match self {
+ Either::Left(l) => l,
+ Either::Right(_) => other,
+ }
+ }
+
+ /// Return left or a default
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<String, u32> = Left("left".to_string());
+ /// assert_eq!(left.left_or_default(), "left");
+ ///
+ /// let right: Either<String, u32> = Right(42);
+ /// assert_eq!(right.left_or_default(), String::default());
+ /// ```
+ pub fn left_or_default(self) -> L
+ where
+ L: Default,
+ {
+ match self {
+ Either::Left(l) => l,
+ Either::Right(_) => L::default(),
+ }
+ }
+
+ /// Returns left value or computes it from a closure
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<String, u32> = Left("3".to_string());
+ /// assert_eq!(left.left_or_else(|_| unreachable!()), "3");
+ ///
+ /// let right: Either<String, u32> = Right(3);
+ /// assert_eq!(right.left_or_else(|x| x.to_string()), "3");
+ /// ```
+ pub fn left_or_else<F>(self, f: F) -> L
+ where
+ F: FnOnce(R) -> L,
+ {
+ match self {
+ Either::Left(l) => l,
+ Either::Right(r) => f(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.
+ ///
+ /// [`right_or_else`]: #method.right_or_else
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let right: Either<&str, &str> = Right("right");
+ /// assert_eq!(right.right_or("foo"), "right");
+ ///
+ /// let left: Either<&str, &str> = Left("left");
+ /// assert_eq!(left.right_or("right"), "right");
+ /// ```
+ pub fn right_or(self, other: R) -> R {
+ match self {
+ Either::Left(_) => other,
+ Either::Right(r) => r,
+ }
+ }
+
+ /// Return right or a default
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<String, u32> = Left("left".to_string());
+ /// assert_eq!(left.right_or_default(), u32::default());
+ ///
+ /// let right: Either<String, u32> = Right(42);
+ /// assert_eq!(right.right_or_default(), 42);
+ /// ```
+ pub fn right_or_default(self) -> R
+ where
+ R: Default,
+ {
+ match self {
+ Either::Left(_) => R::default(),
+ Either::Right(r) => r,
+ }
+ }
+
+ /// Returns right value or computes it from a closure
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<String, u32> = Left("3".to_string());
+ /// assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);
+ ///
+ /// let right: Either<String, u32> = Right(3);
+ /// assert_eq!(right.right_or_else(|_| unreachable!()), 3);
+ /// ```
+ pub fn right_or_else<F>(self, f: F) -> R
+ where
+ F: FnOnce(L) -> R,
+ {
+ match self {
+ Either::Left(l) => f(l),
+ Either::Right(r) => r,
+ }
+ }
+
+ /// Returns the left value
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<_, ()> = Left(3);
+ /// assert_eq!(left.unwrap_left(), 3);
+ /// ```
+ ///
+ /// # Panics
+ ///
+ /// When `Either` is a `Right` value
+ ///
+ /// ```should_panic
+ /// # use either::*;
+ /// let right: Either<(), _> = Right(3);
+ /// right.unwrap_left();
+ /// ```
+ pub fn unwrap_left(self) -> L
+ where
+ R: std::fmt::Debug,
+ {
+ match self {
+ Either::Left(l) => l,
+ Either::Right(r) => {
+ panic!("called `Either::unwrap_left()` on a `Right` value: {:?}", r)
+ }
+ }
+ }
+
+ /// Returns the right value
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let right: Either<(), _> = Right(3);
+ /// assert_eq!(right.unwrap_right(), 3);
+ /// ```
+ ///
+ /// # Panics
+ ///
+ /// When `Either` is a `Left` value
+ ///
+ /// ```should_panic
+ /// # use either::*;
+ /// let left: Either<_, ()> = Left(3);
+ /// left.unwrap_right();
+ /// ```
+ pub fn unwrap_right(self) -> R
+ where
+ L: std::fmt::Debug,
+ {
+ match self {
+ Either::Right(r) => r,
+ Either::Left(l) => panic!("called `Either::unwrap_right()` on a `Left` value: {:?}", l),
+ }
+ }
+
+ /// Returns the left value
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let left: Either<_, ()> = Left(3);
+ /// assert_eq!(left.expect_left("value was Right"), 3);
+ /// ```
+ ///
+ /// # Panics
+ ///
+ /// When `Either` is a `Right` value
+ ///
+ /// ```should_panic
+ /// # use either::*;
+ /// let right: Either<(), _> = Right(3);
+ /// right.expect_left("value was Right");
+ /// ```
+ pub fn expect_left(self, msg: &str) -> L
+ where
+ R: std::fmt::Debug,
+ {
+ match self {
+ Either::Left(l) => l,
+ Either::Right(r) => panic!("{}: {:?}", msg, r),
+ }
+ }
+
+ /// Returns the right value
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use either::*;
+ /// let right: Either<(), _> = Right(3);
+ /// assert_eq!(right.expect_right("value was Left"), 3);
+ /// ```
+ ///
+ /// # Panics
+ ///
+ /// When `Either` is a `Left` value
+ ///
+ /// ```should_panic
+ /// # use either::*;
+ /// let left: Either<_, ()> = Left(3);
+ /// left.expect_right("value was Right");
+ /// ```
+ pub fn expect_right(self, msg: &str) -> R
+ where
+ L: std::fmt::Debug,
+ {
+ match self {
+ Either::Right(r) => r,
+ Either::Left(l) => panic!("{}: {:?}", msg, l),
+ }
+ }
+}
+
+impl<T, L, R> Either<(T, L), (T, R)> {
+ /// Factor out a homogeneous type from an either of pairs.
+ ///
+ /// Here, the homogeneous type is the first element of the pairs.
+ ///
+ /// ```
+ /// use either::*;
+ /// let left: Either<_, (u32, String)> = Left((123, vec![0]));
+ /// assert_eq!(left.factor_first().0, 123);
+ ///
+ /// let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
+ /// assert_eq!(right.factor_first().0, 123);
+ /// ```
+ pub fn factor_first(self) -> (T, Either<L, R>) {
+ match self {
+ Left((t, l)) => (t, Left(l)),
+ Right((t, r)) => (t, Right(r)),
+ }
+ }
+}
+
+impl<T, L, R> Either<(L, T), (R, T)> {
+ /// Factor out a homogeneous type from an either of pairs.
+ ///
+ /// Here, the homogeneous type is the second element of the pairs.
+ ///
+ /// ```
+ /// use either::*;
+ /// let left: Either<_, (String, u32)> = Left((vec![0], 123));
+ /// assert_eq!(left.factor_second().1, 123);
+ ///
+ /// let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
+ /// assert_eq!(right.factor_second().1, 123);
+ /// ```
+ pub fn factor_second(self) -> (Either<L, R>, T) {
+ match self {
+ Left((l, t)) => (Left(l), t),
+ Right((r, t)) => (Right(r), t),
+ }
+ }
+}
+
+impl<T> Either<T, T> {
+ /// Extract the value of an either over two equivalent types.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let left: Either<_, u32> = Left(123);
+ /// assert_eq!(left.into_inner(), 123);
+ ///
+ /// let right: Either<u32, _> = Right(123);
+ /// assert_eq!(right.into_inner(), 123);
+ /// ```
+ pub fn into_inner(self) -> T {
+ either!(self, inner => inner)
+ }
+
+ /// Map `f` over the contained value and return the result in the
+ /// corresponding variant.
+ ///
+ /// ```
+ /// use either::*;
+ ///
+ /// let value: Either<_, i32> = Right(42);
+ ///
+ /// let other = value.map(|x| x * 2);
+ /// assert_eq!(other, Right(84));
+ /// ```
+ pub fn map<F, M>(self, f: F) -> Either<M, M>
+ where
+ F: FnOnce(T) -> M,
+ {
+ match self {
+ Left(l) => Left(f(l)),
+ Right(r) => Right(f(r)),
+ }
+ }
+}
+
+/// Convert from `Result` to `Either` with `Ok => Right` and `Err => Left`.
+impl<L, R> From<Result<R, L>> for Either<L, R> {
+ fn from(r: Result<R, L>) -> Self {
+ match r {
+ Err(e) => Left(e),
+ Ok(o) => Right(o),
+ }
+ }
+}
+
+/// Convert from `Either` to `Result` with `Right => Ok` and `Left => Err`.
+impl<L, R> Into<Result<R, L>> for Either<L, R> {
+ fn into(self) -> Result<R, L> {
+ match self {
+ Left(l) => Err(l),
+ Right(r) => Ok(r),
+ }
+ }
+}
+
+impl<L, R, A> Extend<A> for Either<L, R>
+where
+ L: Extend<A>,
+ R: Extend<A>,
+{
+ fn extend<T>(&mut self, iter: T)
+ where
+ T: IntoIterator<Item = A>,
+ {
+ either!(*self, ref mut inner => inner.extend(iter))
+ }
+}
+
+/// `Either<L, R>` is an iterator if both `L` and `R` are iterators.
+impl<L, R> Iterator for Either<L, R>
+where
+ L: Iterator,
+ R: Iterator<Item = L::Item>,
+{
+ type Item = L::Item;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ either!(*self, ref mut inner => inner.next())
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ either!(*self, ref inner => inner.size_hint())
+ }
+
+ fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
+ where
+ G: FnMut(Acc, Self::Item) -> Acc,
+ {
+ either!(self, inner => inner.fold(init, f))
+ }
+
+ fn count(self) -> usize {
+ either!(self, inner => inner.count())
+ }
+
+ fn last(self) -> Option<Self::Item> {
+ either!(self, inner => inner.last())
+ }
+
+ fn nth(&mut self, n: usize) -> Option<Self::Item> {
+ either!(*self, ref mut inner => inner.nth(n))
+ }
+
+ fn collect<B>(self) -> B
+ where
+ B: iter::FromIterator<Self::Item>,
+ {
+ either!(self, inner => inner.collect())
+ }
+
+ fn all<F>(&mut self, f: F) -> bool
+ where
+ F: FnMut(Self::Item) -> bool,
+ {
+ either!(*self, ref mut inner => inner.all(f))
+ }
+}
+
+impl<L, R> DoubleEndedIterator for Either<L, R>
+where
+ L: DoubleEndedIterator,
+ R: DoubleEndedIterator<Item = L::Item>,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ either!(*self, ref mut inner => inner.next_back())
+ }
+}
+
+impl<L, R> ExactSizeIterator for Either<L, R>
+where
+ L: ExactSizeIterator,
+ R: ExactSizeIterator<Item = L::Item>,
+{
+}
+
+#[cfg(any(test, feature = "use_std"))]
+/// `Either<L, R>` implements `Read` if both `L` and `R` do.
+///
+/// Requires crate feature `"use_std"`
+impl<L, R> Read for Either<L, R>
+where
+ L: Read,
+ R: Read,
+{
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ either!(*self, ref mut inner => inner.read(buf))
+ }
+
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+ either!(*self, ref mut inner => inner.read_to_end(buf))
+ }
+}
+
+#[cfg(any(test, feature = "use_std"))]
+/// Requires crate feature `"use_std"`
+impl<L, R> BufRead for Either<L, R>
+where
+ L: BufRead,
+ R: BufRead,
+{
+ fn fill_buf(&mut self) -> io::Result<&[u8]> {
+ either!(*self, ref mut inner => inner.fill_buf())
+ }
+
+ fn consume(&mut self, amt: usize) {
+ either!(*self, ref mut inner => inner.consume(amt))
+ }
+}
+
+#[cfg(any(test, feature = "use_std"))]
+/// `Either<L, R>` implements `Write` if both `L` and `R` do.
+///
+/// Requires crate feature `"use_std"`
+impl<L, R> Write for Either<L, R>
+where
+ L: Write,
+ R: Write,
+{
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ either!(*self, ref mut inner => inner.write(buf))
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ either!(*self, ref mut inner => inner.flush())
+ }
+}
+
+impl<L, R, Target> AsRef<Target> for Either<L, R>
+where
+ L: AsRef<Target>,
+ R: AsRef<Target>,
+{
+ fn as_ref(&self) -> &Target {
+ either!(*self, ref inner => inner.as_ref())
+ }
+}
+
+macro_rules! impl_specific_ref_and_mut {
+ ($t:ty, $($attr:meta),* ) => {
+ $(#[$attr])*
+ impl<L, R> AsRef<$t> for Either<L, R>
+ where L: AsRef<$t>, R: AsRef<$t>
+ {
+ fn as_ref(&self) -> &$t {
+ either!(*self, ref inner => inner.as_ref())
+ }
+ }
+
+ $(#[$attr])*
+ impl<L, R> AsMut<$t> for Either<L, R>
+ where L: AsMut<$t>, R: AsMut<$t>
+ {
+ fn as_mut(&mut self) -> &mut $t {
+ either!(*self, ref mut inner => inner.as_mut())
+ }
+ }
+ };
+}
+
+impl_specific_ref_and_mut!(str,);
+impl_specific_ref_and_mut!(
+ ::std::path::Path,
+ cfg(feature = "use_std"),
+ doc = "Requires crate feature `use_std`."
+);
+impl_specific_ref_and_mut!(
+ ::std::ffi::OsStr,
+ cfg(feature = "use_std"),
+ doc = "Requires crate feature `use_std`."
+);
+impl_specific_ref_and_mut!(
+ ::std::ffi::CStr,
+ cfg(feature = "use_std"),
+ doc = "Requires crate feature `use_std`."
+);
+
+impl<L, R, Target> AsRef<[Target]> for Either<L, R>
+where
+ L: AsRef<[Target]>,
+ R: AsRef<[Target]>,
+{
+ fn as_ref(&self) -> &[Target] {
+ either!(*self, ref inner => inner.as_ref())
+ }
+}
+
+impl<L, R, Target> AsMut<Target> for Either<L, R>
+where
+ L: AsMut<Target>,
+ R: AsMut<Target>,
+{
+ fn as_mut(&mut self) -> &mut Target {
+ either!(*self, ref mut inner => inner.as_mut())
+ }
+}
+
+impl<L, R, Target> AsMut<[Target]> for Either<L, R>
+where
+ L: AsMut<[Target]>,
+ R: AsMut<[Target]>,
+{
+ fn as_mut(&mut self) -> &mut [Target] {
+ either!(*self, ref mut inner => inner.as_mut())
+ }
+}
+
+impl<L, R> Deref for Either<L, R>
+where
+ L: Deref,
+ R: Deref<Target = L::Target>,
+{
+ type Target = L::Target;
+
+ fn deref(&self) -> &Self::Target {
+ either!(*self, ref inner => &*inner)
+ }
+}
+
+impl<L, R> DerefMut for Either<L, R>
+where
+ L: DerefMut,
+ R: DerefMut<Target = L::Target>,
+{
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ either!(*self, ref mut inner => &mut *inner)
+ }
+}
+
+#[cfg(any(test, feature = "use_std"))]
+/// `Either` implements `Error` if *both* `L` and `R` implement it.
+impl<L, R> Error for Either<L, R>
+where
+ L: Error,
+ R: Error,
+{
+ #[allow(deprecated)]
+ fn description(&self) -> &str {
+ either!(*self, ref inner => inner.description())
+ }
+
+ #[allow(deprecated)]
+ #[allow(unknown_lints, bare_trait_objects)]
+ fn cause(&self) -> Option<&Error> {
+ either!(*self, ref inner => inner.cause())
+ }
+}
+
+impl<L, R> fmt::Display for Either<L, R>
+where
+ L: fmt::Display,
+ R: fmt::Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ either!(*self, ref inner => inner.fmt(f))
+ }
+}
+
+#[test]
+fn basic() {
+ let mut e = Left(2);
+ let r = Right(2);
+ assert_eq!(e, Left(2));
+ e = r;
+ assert_eq!(e, Right(2));
+ assert_eq!(e.left(), None);
+ assert_eq!(e.right(), Some(2));
+ assert_eq!(e.as_ref().right(), Some(&2));
+ assert_eq!(e.as_mut().right(), Some(&mut 2));
+}
+
+#[test]
+fn macros() {
+ fn a() -> Either<u32, u32> {
+ let x: u32 = try_left!(Right(1337u32));
+ Left(x * 2)
+ }
+ assert_eq!(a(), Right(1337));
+
+ fn b() -> Either<String, &'static str> {
+ Right(try_right!(Left("foo bar")))
+ }
+ assert_eq!(b(), Left(String::from("foo bar")));
+}
+
+#[test]
+fn deref() {
+ fn is_str(_: &str) {}
+ let value: Either<String, &str> = Left(String::from("test"));
+ is_str(&*value);
+}
+
+#[test]
+fn iter() {
+ let x = 3;
+ let mut iter = match x {
+ 3 => Left(0..10),
+ _ => Right(17..),
+ };
+
+ assert_eq!(iter.next(), Some(0));
+ assert_eq!(iter.count(), 9);
+}
+
+#[test]
+fn read_write() {
+ use std::io;
+
+ let use_stdio = false;
+ let mockdata = [0xff; 256];
+
+ let mut reader = if use_stdio {
+ Left(io::stdin())
+ } else {
+ Right(&mockdata[..])
+ };
+
+ let mut buf = [0u8; 16];
+ assert_eq!(reader.read(&mut buf).unwrap(), buf.len());
+ assert_eq!(&buf, &mockdata[..buf.len()]);
+
+ let mut mockbuf = [0u8; 256];
+ let mut writer = if use_stdio {
+ Left(io::stdout())
+ } else {
+ Right(&mut mockbuf[..])
+ };
+
+ let buf = [1u8; 16];
+ assert_eq!(writer.write(&buf).unwrap(), buf.len());
+}
+
+#[test]
+#[allow(deprecated)]
+fn error() {
+ let invalid_utf8 = b"\xff";
+ let res = if let Err(error) = ::std::str::from_utf8(invalid_utf8) {
+ Err(Left(error))
+ } else if let Err(error) = "x".parse::<i32>() {
+ Err(Right(error))
+ } else {
+ Ok(())
+ };
+ assert!(res.is_err());
+ res.unwrap_err().description(); // make sure this can be called
+}
+
+/// A helper macro to check if AsRef and AsMut are implemented for a given type.
+macro_rules! check_t {
+ ($t:ty) => {{
+ fn check_ref<T: AsRef<$t>>() {}
+ fn propagate_ref<T1: AsRef<$t>, T2: AsRef<$t>>() {
+ check_ref::<Either<T1, T2>>()
+ }
+ fn check_mut<T: AsMut<$t>>() {}
+ fn propagate_mut<T1: AsMut<$t>, T2: AsMut<$t>>() {
+ check_mut::<Either<T1, T2>>()
+ }
+ }};
+}
+
+// This "unused" method is here to ensure that compilation doesn't fail on given types.
+fn _unsized_ref_propagation() {
+ check_t!(str);
+
+ fn check_array_ref<T: AsRef<[Item]>, Item>() {}
+ fn check_array_mut<T: AsMut<[Item]>, Item>() {}
+
+ fn propagate_array_ref<T1: AsRef<[Item]>, T2: AsRef<[Item]>, Item>() {
+ check_array_ref::<Either<T1, T2>, _>()
+ }
+
+ fn propagate_array_mut<T1: AsMut<[Item]>, T2: AsMut<[Item]>, Item>() {
+ check_array_mut::<Either<T1, T2>, _>()
+ }
+}
+
+// This "unused" method is here to ensure that compilation doesn't fail on given types.
+#[cfg(feature = "use_std")]
+fn _unsized_std_propagation() {
+ check_t!(::std::path::Path);
+ check_t!(::std::ffi::OsStr);
+ check_t!(::std::ffi::CStr);
+}
diff --git a/src/serde_untagged.rs b/src/serde_untagged.rs
new file mode 100644
index 0000000..20de074
--- /dev/null
+++ b/src/serde_untagged.rs
@@ -0,0 +1,73 @@
+//! Untagged serialization/deserialization support for Either<L, R>.
+//!
+//! `Either` uses default, externally-tagged representation.
+//! However, sometimes it is useful to support several alternative types.
+//! For example, we may have a field which is generally Map<String, i32>
+//! but in typical cases Vec<String> would suffice, too.
+//!
+//! ```rust
+//! #[macro_use]
+//! extern crate serde;
+//! // or `use serde::{Serialize, Deserialize};` in newer rust versions.
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! use either::Either;
+//! use std::collections::HashMap;
+//!
+//! #[derive(Serialize, Deserialize, Debug)]
+//! #[serde(transparent)]
+//! struct IntOrString {
+//! #[serde(with = "either::serde_untagged")]
+//! inner: Either<Vec<String>, HashMap<String, i32>>
+//! };
+//!
+//! // serialization
+//! let data = IntOrString {
+//! inner: Either::Left(vec!["Hello".to_string()])
+//! };
+//! // notice: no tags are emitted.
+//! assert_eq!(serde_json::to_string(&data)?, r#"["Hello"]"#);
+//!
+//! // deserialization
+//! let data: IntOrString = serde_json::from_str(
+//! r#"{"a": 0, "b": 14}"#
+//! )?;
+//! println!("found {:?}", data);
+//! # Ok(())
+//! # }
+//! ```
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+enum Either<L, R> {
+ Left(L),
+ Right(R),
+}
+
+pub fn serialize<L, R, S>(this: &super::Either<L, R>, serializer: S) -> Result<S::Ok, S::Error>
+where
+ S: Serializer,
+ L: Serialize,
+ R: Serialize,
+{
+ let untagged = match this {
+ &super::Either::Left(ref left) => Either::Left(left),
+ &super::Either::Right(ref right) => Either::Right(right),
+ };
+ untagged.serialize(serializer)
+}
+
+pub fn deserialize<'de, L, R, D>(deserializer: D) -> Result<super::Either<L, R>, D::Error>
+where
+ D: Deserializer<'de>,
+ L: Deserialize<'de>,
+ R: Deserialize<'de>,
+{
+ match Either::deserialize(deserializer) {
+ Ok(Either::Left(left)) => Ok(super::Either::Left(left)),
+ Ok(Either::Right(right)) => Ok(super::Either::Right(right)),
+ Err(error) => Err(error),
+ }
+}
diff --git a/src/serde_untagged_optional.rs b/src/serde_untagged_optional.rs
new file mode 100644
index 0000000..f0cca36
--- /dev/null
+++ b/src/serde_untagged_optional.rs
@@ -0,0 +1,78 @@
+//! Untagged serialization/deserialization support for Option<Either<L, R>>.
+//!
+//! `Either` uses default, externally-tagged representation.
+//! However, sometimes it is useful to support several alternative types.
+//! For example, we may have a field which is generally Map<String, i32>
+//! but in typical cases Vec<String> would suffice, too.
+//!
+//! ```rust
+//! #[macro_use]
+//! extern crate serde;
+//! // or `use serde::{Serialize, Deserialize};` in newer rust versions.
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! use either::Either;
+//! use std::collections::HashMap;
+//!
+//! #[derive(Serialize, Deserialize, Debug)]
+//! #[serde(transparent)]
+//! struct IntOrString {
+//! #[serde(with = "either::serde_untagged_optional")]
+//! inner: Option<Either<Vec<String>, HashMap<String, i32>>>
+//! };
+//!
+//! // serialization
+//! let data = IntOrString {
+//! inner: Some(Either::Left(vec!["Hello".to_string()]))
+//! };
+//! // notice: no tags are emitted.
+//! assert_eq!(serde_json::to_string(&data)?, r#"["Hello"]"#);
+//!
+//! // deserialization
+//! let data: IntOrString = serde_json::from_str(
+//! r#"{"a": 0, "b": 14}"#
+//! )?;
+//! println!("found {:?}", data);
+//! # Ok(())
+//! # }
+//! ```
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+enum Either<L, R> {
+ Left(L),
+ Right(R),
+}
+
+pub fn serialize<L, R, S>(
+ this: &Option<super::Either<L, R>>,
+ serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+ S: Serializer,
+ L: Serialize,
+ R: Serialize,
+{
+ let untagged = match this {
+ &Some(super::Either::Left(ref left)) => Some(Either::Left(left)),
+ &Some(super::Either::Right(ref right)) => Some(Either::Right(right)),
+ &None => None,
+ };
+ untagged.serialize(serializer)
+}
+
+pub fn deserialize<'de, L, R, D>(deserializer: D) -> Result<Option<super::Either<L, R>>, D::Error>
+where
+ D: Deserializer<'de>,
+ L: Deserialize<'de>,
+ R: Deserialize<'de>,
+{
+ match Option::deserialize(deserializer) {
+ Ok(Some(Either::Left(left))) => Ok(Some(super::Either::Left(left))),
+ Ok(Some(Either::Right(right))) => Ok(Some(super::Either::Right(right))),
+ Ok(None) => Ok(None),
+ Err(error) => Err(error),
+ }
+}
