diff options
Diffstat (limited to 'vendor/either')
| -rw-r--r-- | vendor/either/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/either/Cargo.toml | 40 | ||||
| -rw-r--r-- | vendor/either/LICENSE-APACHE | 201 | ||||
| -rw-r--r-- | vendor/either/LICENSE-MIT | 25 | ||||
| -rw-r--r-- | vendor/either/README-crates.io.md | 10 | ||||
| -rw-r--r-- | vendor/either/README.rst | 168 | ||||
| -rw-r--r-- | vendor/either/src/lib.rs | 1530 | ||||
| -rw-r--r-- | vendor/either/src/serde_untagged.rs | 69 | ||||
| -rw-r--r-- | vendor/either/src/serde_untagged_optional.rs | 74 |
9 files changed, 0 insertions, 2118 deletions
diff --git a/vendor/either/.cargo-checksum.json b/vendor/either/.cargo-checksum.json deleted file mode 100644 index f167a9d..0000000 --- a/vendor/either/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"Cargo.toml":"139ac63ca03225b8349feb97c89a5e0e0b1a266eed726a53a5633402f610841c","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7576269ea71f767b99297934c0b2367532690f8c4badc695edf8e04ab6a1e545","README-crates.io.md":"b775991a01ab4a0a8de6169f597775319d9ce8178f5c74ccdc634f13a286b20c","README.rst":"28389277f35b722b5cc5872543e6a3c013b933b45e5a2178ec47d163cadcf602","src/lib.rs":"e4c683f2e3f029a1bb81def1f622427af2f5b95afda2bf25e5b2c3c8c8429127","src/serde_untagged.rs":"e826ee0ab31616e49c3e3f3711c8441001ee424b3e7a8c4c466cfcc4f8a7701a","src/serde_untagged_optional.rs":"86265f09d0795428bb2ce013b070d1badf1e2210217844a9ff3f04b2795868ab"},"package":"a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"}
\ No newline at end of file diff --git a/vendor/either/Cargo.toml b/vendor/either/Cargo.toml deleted file mode 100644 index 50ed048..0000000 --- a/vendor/either/Cargo.toml +++ /dev/null @@ -1,40 +0,0 @@ -# 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] -edition = "2018" -name = "either" -version = "1.9.0" -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 OR 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/vendor/either/LICENSE-APACHE b/vendor/either/LICENSE-APACHE deleted file mode 100644 index 16fe87b..0000000 --- a/vendor/either/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/vendor/either/LICENSE-MIT b/vendor/either/LICENSE-MIT deleted file mode 100644 index 9203baa..0000000 --- a/vendor/either/LICENSE-MIT +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2015 - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/vendor/either/README-crates.io.md b/vendor/either/README-crates.io.md deleted file mode 100644 index d368902..0000000 --- a/vendor/either/README-crates.io.md +++ /dev/null @@ -1,10 +0,0 @@ -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/vendor/either/README.rst b/vendor/either/README.rst deleted file mode 100644 index 85ee6c3..0000000 --- a/vendor/either/README.rst +++ /dev/null @@ -1,168 +0,0 @@ - -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://github.com/bluss/either/workflows/CI/badge.svg?branch=master -.. _build_status: https://github.com/bluss/either/actions - -.. |crates| image:: https://img.shields.io/crates/v/either.svg -.. _crates: https://crates.io/crates/either - -How to use with cargo:: - - [dependencies] - either = "1.8" - - -Recent Changes --------------- - -- 1.9.0 - - - Add new methods ``.map_either()`` and ``.map_either_with()``, by @nasadorian (#82) - -- 1.8.1 - - - Clarified that the multiple licenses are combined with OR. - -- 1.8.0 - - - **MSRV**: ``either`` now requires Rust 1.36 or later. - - - Add new methods ``.as_pin_ref()`` and ``.as_pin_mut()`` to project a - pinned ``Either`` as inner ``Pin`` variants, by @cuviper (#77) - - - Implement the ``Future`` trait, by @cuviper (#77) - - - Specialize more methods of the ``io`` traits, by @Kixunil and @cuviper (#75) - -- 1.7.0 - - - **MSRV**: ``either`` now requires Rust 1.31 or later. - - - Export the macro ``for_both!``, by @thomaseizinger (#58) - - - Implement the ``io::Seek`` trait, by @Kerollmops (#60) - - - Add new method ``.either_into()`` for ``Into`` conversion, by @TonalidadeHidrica (#63) - - - Add new methods ``.factor_ok()``, ``.factor_err()``, and ``.factor_none()``, - by @zachs18 (#67) - - - Specialize ``source`` in the ``Error`` implementation, by @thomaseizinger (#69) - - - Specialize more iterator methods and implement the ``FusedIterator`` trait, - by @Ten0 (#66) and @cuviper (#71) - - - Specialize ``Clone::clone_from``, by @cuviper (#72) - -- 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 -https://www.apache.org/licenses/LICENSE-2.0 or the MIT license -https://opensource.org/licenses/MIT, at your -option. This file may not be copied, modified, or distributed -except according to those terms. diff --git a/vendor/either/src/lib.rs b/vendor/either/src/lib.rs deleted file mode 100644 index d7fbf2c..0000000 --- a/vendor/either/src/lib.rs +++ /dev/null @@ -1,1530 +0,0 @@ -//! 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/")] -#![no_std] - -#[cfg(any(test, feature = "use_std"))] -extern crate std; - -#[cfg(feature = "serde")] -pub mod serde_untagged; - -#[cfg(feature = "serde")] -pub mod serde_untagged_optional; - -use core::convert::{AsMut, AsRef}; -use core::fmt; -use core::future::Future; -use core::iter; -use core::ops::Deref; -use core::ops::DerefMut; -use core::pin::Pin; - -#[cfg(any(test, feature = "use_std"))] -use std::error::Error; -#[cfg(any(test, feature = "use_std"))] -use std::io::{self, BufRead, Read, Seek, SeekFrom, Write}; - -pub use crate::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(serde::Serialize, serde::Deserialize))] -#[derive(Copy, 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), -} - -/// Evaluate the provided expression for both [`Either::Left`] and [`Either::Right`]. -/// -/// This macro is useful in cases where both sides of [`Either`] can be interacted with -/// in the same way even though the don't share the same type. -/// -/// Syntax: `either::for_both!(` *expression* `,` *pattern* `=>` *expression* `)` -/// -/// # Example -/// -/// ``` -/// use either::Either; -/// -/// fn length(owned_or_borrowed: Either<String, &'static str>) -> usize { -/// either::for_both!(owned_or_borrowed, s => s.len()) -/// } -/// -/// fn main() { -/// let borrowed = Either::Right("Hello world!"); -/// let owned = Either::Left("Hello world!".to_owned()); -/// -/// assert_eq!(length(borrowed), 12); -/// assert_eq!(length(owned), 12); -/// } -/// ``` -#[macro_export] -macro_rules! for_both { - ($value:expr, $pattern:pat => $result:expr) => { - match $value { - $crate::Either::Left($pattern) => $result, - $crate::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 -/// -/// ``` -/// use either::{Either, Left, Right}; -/// -/// fn twice(wrapper: Either<u32, &str>) -> Either<u32, &str> { -/// let value = either::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(::core::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(::core::convert::From::from(err)), - $crate::Right(val) => val, - } - }; -} - -impl<L: Clone, R: Clone> Clone for Either<L, R> { - fn clone(&self) -> Self { - match self { - Left(inner) => Left(inner.clone()), - Right(inner) => Right(inner.clone()), - } - } - - fn clone_from(&mut self, source: &Self) { - match (self, source) { - (Left(dest), Left(source)) => dest.clone_from(source), - (Right(dest), Right(source)) => dest.clone_from(source), - (dest, source) => *dest = source.clone(), - } - } -} - -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 `Pin<&Either<L, R>>` to `Either<Pin<&L>, Pin<&R>>`, - /// pinned projections of the inner variants. - pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&L>, Pin<&R>> { - // SAFETY: We can use `new_unchecked` because the `inner` parts are - // guaranteed to be pinned, as they come from `self` which is pinned. - unsafe { - match *Pin::get_ref(self) { - Left(ref inner) => Left(Pin::new_unchecked(inner)), - Right(ref inner) => Right(Pin::new_unchecked(inner)), - } - } - } - - /// Convert `Pin<&mut Either<L, R>>` to `Either<Pin<&mut L>, Pin<&mut R>>`, - /// pinned projections of the inner variants. - pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut L>, Pin<&mut R>> { - // SAFETY: `get_unchecked_mut` is fine because we don't move anything. - // We can use `new_unchecked` because the `inner` parts are guaranteed - // to be pinned, as they come from `self` which is pinned, and we never - // offer an unpinned `&mut L` or `&mut R` through `Pin<&mut Self>`. We - // also don't have an implementation of `Drop`, nor manual `Unpin`. - unsafe { - match *Pin::get_unchecked_mut(self) { - Left(ref mut inner) => Left(Pin::new_unchecked(inner)), - Right(ref mut inner) => Right(Pin::new_unchecked(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 the functions `f` and `g` to the `Left` and `Right` variants - /// respectively. This is equivalent to - /// [bimap](https://hackage.haskell.org/package/bifunctors-5/docs/Data-Bifunctor.html) - /// in functional programming. - /// - /// ``` - /// use either::*; - /// - /// let f = |s: String| s.len(); - /// let g = |u: u8| u.to_string(); - /// - /// let left: Either<String, u8> = Left("loopy".into()); - /// assert_eq!(left.map_either(f, g), Left(5)); - /// - /// let right: Either<String, u8> = Right(42); - /// assert_eq!(right.map_either(f, g), Right("42".into())); - /// ``` - pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> - where - F: FnOnce(L) -> M, - G: FnOnce(R) -> S, - { - match self { - Left(l) => Left(f(l)), - Right(r) => Right(g(r)), - } - } - - /// Similar to [`map_either`], with an added context `ctx` accessible to - /// both functions. - /// - /// ``` - /// use either::*; - /// - /// 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, u: usize| { *sum += u; u.to_string() }; - /// - /// let left: Either<String, usize> = Left("loopy".into()); - /// assert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left("LOOPY".into())); - /// - /// let right: Either<String, usize> = Right(42); - /// assert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right("42".into())); - /// - /// assert_eq!(sum, 47); - /// ``` - pub fn map_either_with<Ctx, F, G, M, S>(self, ctx: Ctx, f: F, g: G) -> Either<M, S> - where - F: FnOnce(Ctx, L) -> M, - G: FnOnce(Ctx, R) -> S, - { - match self { - Left(l) => Left(f(ctx, l)), - Right(r) => Right(g(ctx, 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])); - /// ``` - #[allow(clippy::should_implement_trait)] - 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: core::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: core::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: core::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: core::fmt::Debug, - { - match self { - Either::Right(r) => r, - Either::Left(l) => panic!("{}: {:?}", msg, l), - } - } - - /// Convert the contained value into `T` - /// - /// # Examples - /// - /// ``` - /// # use either::*; - /// // Both u16 and u32 can be converted to u64. - /// let left: Either<u16, u32> = Left(3u16); - /// assert_eq!(left.either_into::<u64>(), 3u64); - /// let right: Either<u16, u32> = Right(7u32); - /// assert_eq!(right.either_into::<u64>(), 7u64); - /// ``` - pub fn either_into<T>(self) -> T - where - L: Into<T>, - R: Into<T>, - { - match self { - Either::Left(l) => l.into(), - Either::Right(r) => r.into(), - } - } -} - -impl<L, R> Either<Option<L>, Option<R>> { - /// Factors out `None` from an `Either` of [`Option`]. - /// - /// ``` - /// use either::*; - /// let left: Either<_, Option<String>> = Left(Some(vec![0])); - /// assert_eq!(left.factor_none(), Some(Left(vec![0]))); - /// - /// let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new())); - /// assert_eq!(right.factor_none(), Some(Right(String::new()))); - /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] - pub fn factor_none(self) -> Option<Either<L, R>> { - match self { - Left(l) => l.map(Either::Left), - Right(r) => r.map(Either::Right), - } - } -} - -impl<L, R, E> Either<Result<L, E>, Result<R, E>> { - /// Factors out a homogenous type from an `Either` of [`Result`]. - /// - /// Here, the homogeneous type is the `Err` type of the [`Result`]. - /// - /// ``` - /// use either::*; - /// let left: Either<_, Result<String, u32>> = Left(Ok(vec![0])); - /// assert_eq!(left.factor_err(), Ok(Left(vec![0]))); - /// - /// let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new())); - /// assert_eq!(right.factor_err(), Ok(Right(String::new()))); - /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] - pub fn factor_err(self) -> Result<Either<L, R>, E> { - match self { - Left(l) => l.map(Either::Left), - Right(r) => r.map(Either::Right), - } - } -} - -impl<T, L, R> Either<Result<T, L>, Result<T, R>> { - /// Factors out a homogenous type from an `Either` of [`Result`]. - /// - /// Here, the homogeneous type is the `Ok` type of the [`Result`]. - /// - /// ``` - /// use either::*; - /// let left: Either<_, Result<u32, String>> = Left(Err(vec![0])); - /// assert_eq!(left.factor_ok(), Err(Left(vec![0]))); - /// - /// let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new())); - /// assert_eq!(right.factor_ok(), Err(Right(String::new()))); - /// ``` - // TODO(MSRV): doc(alias) was stabilized in Rust 1.48 - // #[doc(alias = "transpose")] - pub fn factor_ok(self) -> Result<T, Either<L, R>> { - match self { - Left(l) => l.map_err(Either::Left), - Right(r) => r.map_err(Either::Right), - } - } -} - -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 { - for_both!(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`. -#[allow(clippy::from_over_into)] // From requires RFC 2451, Rust 1.41 -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>, - { - for_both!(*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> { - for_both!(*self, ref mut inner => inner.next()) - } - - fn size_hint(&self) -> (usize, Option<usize>) { - for_both!(*self, ref inner => inner.size_hint()) - } - - fn fold<Acc, G>(self, init: Acc, f: G) -> Acc - where - G: FnMut(Acc, Self::Item) -> Acc, - { - for_both!(self, inner => inner.fold(init, f)) - } - - fn for_each<F>(self, f: F) - where - F: FnMut(Self::Item), - { - for_both!(self, inner => inner.for_each(f)) - } - - fn count(self) -> usize { - for_both!(self, inner => inner.count()) - } - - fn last(self) -> Option<Self::Item> { - for_both!(self, inner => inner.last()) - } - - fn nth(&mut self, n: usize) -> Option<Self::Item> { - for_both!(*self, ref mut inner => inner.nth(n)) - } - - fn collect<B>(self) -> B - where - B: iter::FromIterator<Self::Item>, - { - for_both!(self, inner => inner.collect()) - } - - fn partition<B, F>(self, f: F) -> (B, B) - where - B: Default + Extend<Self::Item>, - F: FnMut(&Self::Item) -> bool, - { - for_both!(self, inner => inner.partition(f)) - } - - fn all<F>(&mut self, f: F) -> bool - where - F: FnMut(Self::Item) -> bool, - { - for_both!(*self, ref mut inner => inner.all(f)) - } - - fn any<F>(&mut self, f: F) -> bool - where - F: FnMut(Self::Item) -> bool, - { - for_both!(*self, ref mut inner => inner.any(f)) - } - - fn find<P>(&mut self, predicate: P) -> Option<Self::Item> - where - P: FnMut(&Self::Item) -> bool, - { - for_both!(*self, ref mut inner => inner.find(predicate)) - } - - fn find_map<B, F>(&mut self, f: F) -> Option<B> - where - F: FnMut(Self::Item) -> Option<B>, - { - for_both!(*self, ref mut inner => inner.find_map(f)) - } - - fn position<P>(&mut self, predicate: P) -> Option<usize> - where - P: FnMut(Self::Item) -> bool, - { - for_both!(*self, ref mut inner => inner.position(predicate)) - } -} - -impl<L, R> DoubleEndedIterator for Either<L, R> -where - L: DoubleEndedIterator, - R: DoubleEndedIterator<Item = L::Item>, -{ - fn next_back(&mut self) -> Option<Self::Item> { - for_both!(*self, ref mut inner => inner.next_back()) - } - - // TODO(MSRV): This was stabilized in Rust 1.37 - // fn nth_back(&mut self, n: usize) -> Option<Self::Item> { - // for_both!(*self, ref mut inner => inner.nth_back(n)) - // } - - fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc - where - G: FnMut(Acc, Self::Item) -> Acc, - { - for_both!(self, inner => inner.rfold(init, f)) - } - - fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> - where - P: FnMut(&Self::Item) -> bool, - { - for_both!(*self, ref mut inner => inner.rfind(predicate)) - } -} - -impl<L, R> ExactSizeIterator for Either<L, R> -where - L: ExactSizeIterator, - R: ExactSizeIterator<Item = L::Item>, -{ - fn len(&self) -> usize { - for_both!(*self, ref inner => inner.len()) - } -} - -impl<L, R> iter::FusedIterator for Either<L, R> -where - L: iter::FusedIterator, - R: iter::FusedIterator<Item = L::Item>, -{ -} - -/// `Either<L, R>` is a future if both `L` and `R` are futures. -impl<L, R> Future for Either<L, R> -where - L: Future, - R: Future<Output = L::Output>, -{ - type Output = L::Output; - - fn poll( - self: Pin<&mut Self>, - cx: &mut core::task::Context<'_>, - ) -> core::task::Poll<Self::Output> { - for_both!(self.as_pin_mut(), inner => inner.poll(cx)) - } -} - -#[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> { - for_both!(*self, ref mut inner => inner.read(buf)) - } - - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - for_both!(*self, ref mut inner => inner.read_exact(buf)) - } - - fn read_to_end(&mut self, buf: &mut std::vec::Vec<u8>) -> io::Result<usize> { - for_both!(*self, ref mut inner => inner.read_to_end(buf)) - } - - fn read_to_string(&mut self, buf: &mut std::string::String) -> io::Result<usize> { - for_both!(*self, ref mut inner => inner.read_to_string(buf)) - } -} - -#[cfg(any(test, feature = "use_std"))] -/// `Either<L, R>` implements `Seek` if both `L` and `R` do. -/// -/// Requires crate feature `"use_std"` -impl<L, R> Seek for Either<L, R> -where - L: Seek, - R: Seek, -{ - fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { - for_both!(*self, ref mut inner => inner.seek(pos)) - } -} - -#[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]> { - for_both!(*self, ref mut inner => inner.fill_buf()) - } - - fn consume(&mut self, amt: usize) { - for_both!(*self, ref mut inner => inner.consume(amt)) - } - - fn read_until(&mut self, byte: u8, buf: &mut std::vec::Vec<u8>) -> io::Result<usize> { - for_both!(*self, ref mut inner => inner.read_until(byte, buf)) - } - - fn read_line(&mut self, buf: &mut std::string::String) -> io::Result<usize> { - for_both!(*self, ref mut inner => inner.read_line(buf)) - } -} - -#[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> { - for_both!(*self, ref mut inner => inner.write(buf)) - } - - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - for_both!(*self, ref mut inner => inner.write_all(buf)) - } - - fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> { - for_both!(*self, ref mut inner => inner.write_fmt(fmt)) - } - - fn flush(&mut self) -> io::Result<()> { - for_both!(*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 { - for_both!(*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 { - for_both!(*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 { - for_both!(*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] { - for_both!(*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 { - for_both!(*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] { - for_both!(*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 { - for_both!(*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 { - for_both!(*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, -{ - fn source(&self) -> Option<&(dyn Error + 'static)> { - for_both!(*self, ref inner => inner.source()) - } - - #[allow(deprecated)] - fn description(&self) -> &str { - for_both!(*self, ref inner => inner.description()) - } - - #[allow(deprecated)] - fn cause(&self) -> Option<&dyn Error> { - for_both!(*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 { - for_both!(*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() { - use std::string::String; - - 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() { - use std::string::String; - - 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 seek() { - use std::io; - - let use_empty = false; - let mut mockdata = [0x00; 256]; - for i in 0..256 { - mockdata[i] = i as u8; - } - - let mut reader = if use_empty { - // Empty didn't impl Seek until Rust 1.51 - Left(io::Cursor::new([])) - } else { - Right(io::Cursor::new(&mockdata[..])) - }; - - let mut buf = [0u8; 16]; - assert_eq!(reader.read(&mut buf).unwrap(), buf.len()); - assert_eq!(buf, mockdata[..buf.len()]); - - // the first read should advance the cursor and return the next 16 bytes thus the `ne` - assert_eq!(reader.read(&mut buf).unwrap(), buf.len()); - assert_ne!(buf, mockdata[..buf.len()]); - - // if the seek operation fails it should read 16..31 instead of 0..15 - reader.seek(io::SeekFrom::Start(0)).unwrap(); - assert_eq!(reader.read(&mut buf).unwrap(), buf.len()); - assert_eq!(buf, mockdata[..buf.len()]); -} - -#[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/vendor/either/src/serde_untagged.rs b/vendor/either/src/serde_untagged.rs deleted file mode 100644 index 72078c3..0000000 --- a/vendor/either/src/serde_untagged.rs +++ /dev/null @@ -1,69 +0,0 @@ -//! 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 -//! # fn main() -> Result<(), Box<dyn std::error::Error>> { -//! use either::Either; -//! use std::collections::HashMap; -//! -//! #[derive(serde::Serialize, serde::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(serde::Serialize, serde::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(left) => Either::Left(left), - super::Either::Right(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/vendor/either/src/serde_untagged_optional.rs b/vendor/either/src/serde_untagged_optional.rs deleted file mode 100644 index fb3239a..0000000 --- a/vendor/either/src/serde_untagged_optional.rs +++ /dev/null @@ -1,74 +0,0 @@ -//! 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 -//! # fn main() -> Result<(), Box<dyn std::error::Error>> { -//! use either::Either; -//! use std::collections::HashMap; -//! -//! #[derive(serde::Serialize, serde::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(left)) => Some(Either::Left(left)), - Some(super::Either::Right(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), - } -} |