proofs.rs

either 1.19.0

proofs.rs claims for either 1.19.0
README badge

Claims in public reports for version 1.19.0.

[![proofs.rs](https://img.shields.io/endpoint?url=https%3A%2F%2Fproofs.rs%2Fapi%2Fv1%2Fcrates%2Feither%2F1.19.0%2Fbadge)](https://proofs.rs/crate/either?version=1.19.0)

The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.

crates.io

Reports (1)

#27 Either branch operations, payload conversions and conditional composition
Aeneas be86ab0 · 41 claims · nyuichi ·

Findings (0)

For version 1.19.0. Statuses are author reported.

No findings reported for this version.

APIs (186)

APIs are imported from documentation or named in published verification records. 41 have at least one claim; a count says nothing about how strong each claim is.

APIClaims · findings

Functions

pub fn serde_untagged::deserialize<'de, L, R, D>(deserializer: D) -> Result<super::Either<L, R>, <D as serde_core::de::Deserializer>::Error> where D: Deserializer<'de>, L: Deserialize<'de>, R: Deserialize<'de>—
pub fn serde_untagged::serialize<L, R, S>(this: &super::Either<L, R>, serializer: S) -> Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: Serializer, L: Serialize, R: Serialize—
pub fn serde_untagged_optional::deserialize<'de, L, R, D>(deserializer: D) -> Result<Option<super::Either<L, R>>, <D as serde_core::de::Deserializer>::Error> where D: Deserializer<'de>, L: Deserialize<'de>, R: Deserialize<'de>—
pub fn serde_untagged_optional::serialize<L, R, S>(this: &Option<super::Either<L, R>>, serializer: S) -> Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: Serializer, L: Serialize, R: Serialize—

Associated functions

No associated functions.

Methods

impl Either<&mut L, &mut R>

pub fn cloned(self: Self) -> Either<L, R> where L: Clone, R: Clone—
pub fn copied(self: Self) -> Either<L, R> where L: Copy, R: Copy—

impl Either<(L, T), (R, T)>

pub fn factor_second(self: Self) -> (Either<L, R>, T)1 claim

impl Either<(T, L), (T, R)>

pub fn factor_first(self: Self) -> (T, Either<L, R>)1 claim

impl Either<L, R>

pub fn as_mut(self: &mut Self) -> Either<&mut L, &mut R>1 claim
pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut L>, Pin<&mut R>>—
pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&L>, Pin<&R>>—
pub fn as_ref(self: &Self) -> Either<&L, &R>1 claim
pub fn either<F, G, T>(self: Self, f: F, g: G) -> T where F: FnOnce(L) -> T, G: FnOnce(R) -> T1 claim
pub fn either_into<T>(self: Self) -> T where L: Into<T>, R: Into<T>1 claim
pub fn either_with<Ctx, F, G, T>(self: Self, ctx: Ctx, f: F, g: G) -> T where F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, R) -> T1 claim
pub fn expect_left(self: Self, msg: &str) -> L where R: core::fmt::Debug—
pub fn expect_right(self: Self, msg: &str) -> R where L: core::fmt::Debug—
pub fn factor_into_iter(self: Self) -> IterEither<<L as core::iter::traits::collect::IntoIterator>::IntoIter, <R as core::iter::traits::collect::IntoIterator>::IntoIter> where L: IntoIterator, R: IntoIterator—
pub fn factor_iter(self: &Self) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> where for<'a> &'a L: IntoIterator, for<'a> &'a R: IntoIterator—
pub fn factor_iter_mut(self: &mut Self) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> where for<'a> &'a mut L: IntoIterator, for<'a> &'a mut R: IntoIterator—
pub fn flip(self: Self) -> Either<R, L>1 claim
pub fn inspect_left<F>(self: Self, f: F) -> Self where F: FnOnce(&L)1 claim
pub fn inspect_right<F>(self: Self, f: F) -> Self where F: FnOnce(&R)1 claim
pub fn into_iter(self: Self) -> Either<<L as core::iter::traits::collect::IntoIterator>::IntoIter, <R as core::iter::traits::collect::IntoIterator>::IntoIter> where L: IntoIterator, R: IntoIterator<Item = <L as core::iter::traits::collect::IntoIterator>::Item>—
pub fn is_left(self: &Self) -> bool1 claim
pub fn is_left_and<F>(self: Self, f: F) -> bool where F: FnOnce(L) -> bool1 claim
pub fn is_left_or<F>(self: Self, f: F) -> bool where F: FnOnce(R) -> bool1 claim
pub fn is_right(self: &Self) -> bool1 claim
pub fn is_right_and<F>(self: Self, f: F) -> bool where F: FnOnce(R) -> bool1 claim
pub fn is_right_or<F>(self: Self, f: F) -> bool where F: FnOnce(L) -> bool1 claim
pub fn iter(self: &Self) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> where for<'a> &'a L: IntoIterator, for<'a> &'a R: IntoIterator<Item = <&'a L as IntoIterator>::Item>—
pub fn iter_mut(self: &mut Self) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> where for<'a> &'a mut L: IntoIterator, for<'a> &'a mut R: IntoIterator<Item = <&'a mut L as IntoIterator>::Item>—
pub fn left(self: Self) -> Option<L>1 claim
pub fn left_and<S>(self: Self, other: Either<S, R>) -> Either<S, R>1 claim
pub fn left_and_then<F, S>(self: Self, f: F) -> Either<S, R> where F: FnOnce(L) -> Either<S, R>1 claim
pub fn left_or(self: Self, other: L) -> L1 claim
pub fn left_or_default(self: Self) -> L where L: Default1 claim
pub fn left_or_else<F>(self: Self, f: F) -> L where F: FnOnce(R) -> L1 claim
pub fn map_either<F, G, M, S>(self: Self, f: F, g: G) -> Either<M, S> where F: FnOnce(L) -> M, G: FnOnce(R) -> S1 claim
pub fn map_either_with<Ctx, F, G, M, S>(self: Self, ctx: Ctx, f: F, g: G) -> Either<M, S> where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S1 claim
pub fn map_left<F, M>(self: Self, f: F) -> Either<M, R> where F: FnOnce(L) -> M1 claim
pub fn map_left_or<F, S>(self: Self, default: S, f: F) -> S where F: FnOnce(L) -> S1 claim
pub fn map_right<F, S>(self: Self, f: F) -> Either<L, S> where F: FnOnce(R) -> S1 claim
pub fn map_right_or<F, S>(self: Self, default: S, f: F) -> S where F: FnOnce(R) -> S1 claim
pub fn right(self: Self) -> Option<R>1 claim
pub fn right_and<S>(self: Self, other: Either<L, S>) -> Either<L, S>1 claim
pub fn right_and_then<F, S>(self: Self, f: F) -> Either<L, S> where F: FnOnce(R) -> Either<L, S>1 claim
pub fn right_or(self: Self, other: R) -> R1 claim
pub fn right_or_default(self: Self) -> R where R: Default1 claim
pub fn right_or_else<F>(self: Self, f: F) -> R where F: FnOnce(L) -> R1 claim
pub fn unwrap_left(self: Self) -> L where R: core::fmt::Debug—
pub fn unwrap_right(self: Self) -> R where L: core::fmt::Debug—

impl Either<T, T>

pub fn into_inner(self: Self) -> T—
pub fn map<F, M>(self: Self, f: F) -> Either<M, M> where F: FnOnce(T) -> M—

impl Either<core::option::Option<L>, core::option::Option<R>>

pub fn factor_none(self: Self) -> Option<Either<L, R>>1 claim

impl Either<core::result::Result<L, E>, core::result::Result<R, E>>

pub fn factor_err(self: Self) -> Result<Either<L, R>, E>—

impl Either<core::result::Result<T, L>, core::result::Result<T, R>>

pub fn factor_ok(self: Self) -> Result<T, Either<L, R>>—

Traits

trait IntoEither

pub fn into_either(self: Self, into_left: bool) -> Either<Self, Self>—
pub fn into_either_with<F>(self: Self, into_left: F) -> Either<Self, Self> where F: FnOnce(&Self) -> bool—

Trait implementations

impl alloc::io::buf_read::BufRead for Either<L, R>

pub fn consume(self: &mut Self, amt: usize)—
pub fn fill_buf(self: &mut Self) -> io::Result<&[u8]>—
pub fn read_line(self: &mut Self, buf: &mut std::string::String) -> io::Result<usize>—
pub fn read_until(self: &mut Self, byte: u8, buf: &mut std::vec::Vec<u8>) -> io::Result<usize>—

impl alloc::io::read::Read for Either<L, R>

pub fn read(self: &mut Self, buf: &mut [u8]) -> io::Result<usize>—
pub fn read_exact(self: &mut Self, buf: &mut [u8]) -> io::Result<()>—
pub fn read_to_end(self: &mut Self, buf: &mut std::vec::Vec<u8>) -> io::Result<usize>—
pub fn read_to_string(self: &mut Self, buf: &mut std::string::String) -> io::Result<usize>—

impl core::clone::Clone for …

fn clone2 implementations—
impl core::clone::Clone for Either<L, R>—
impl core::clone::Clone for IterEither<L, R>—
pub fn clone_from(self: &mut Self, source: &Self)—

impl core::cmp::Ord for Either<L, R>

pub fn cmp(self: &Self, other: &Self) -> $crate::cmp::Ordering—

impl core::cmp::PartialEq for Either<L, R>

pub fn eq(self: &Self, other: &Self) -> bool—

impl core::cmp::PartialOrd for Either<L, R>

pub fn partial_cmp(self: &Self, other: &Self) -> $crate::option::Option<$crate::cmp::Ordering>—

impl core::convert::AsMut<Target> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut Target—

impl core::convert::AsMut<[Target]> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut [Target]—

impl core::convert::AsMut<core::ffi::c_str::CStr> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut ::std::ffi::CStr—

impl core::convert::AsMut<std::ffi::os_str::OsStr> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut ::std::ffi::OsStr—

impl core::convert::AsMut<std::path::Path> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut ::std::path::Path—

impl core::convert::AsMut<str> for Either<L, R>

pub fn as_mut(self: &mut Self) -> &mut str—

impl core::convert::AsRef<Target> for Either<L, R>

pub fn as_ref(self: &Self) -> &Target—

impl core::convert::AsRef<[Target]> for Either<L, R>

pub fn as_ref(self: &Self) -> &[Target]—

impl core::convert::AsRef<core::ffi::c_str::CStr> for Either<L, R>

pub fn as_ref(self: &Self) -> &::std::ffi::CStr—

impl core::convert::AsRef<std::ffi::os_str::OsStr> for Either<L, R>

pub fn as_ref(self: &Self) -> &::std::ffi::OsStr—

impl core::convert::AsRef<std::path::Path> for Either<L, R>

pub fn as_ref(self: &Self) -> &::std::path::Path—

impl core::convert::AsRef<str> for Either<L, R>

pub fn as_ref(self: &Self) -> &str—

impl core::convert::From<core::result::Result<R, L>> for Either<L, R>

pub fn from(r: Result<R, L>) -> Self—

impl core::convert::From<either::Either<L, R>> for core::result::Result<R, L>

pub fn from(val: Either<L, R>) -> Self—

impl core::error::Error for Either<L, R>

pub fn cause(self: &Self) -> Option<&dyn Error>—
pub fn description(self: &Self) -> &str—
pub fn source(self: &Self) -> Option<&dyn Error + 'static>—

impl core::fmt::Binary for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::Debug for …

fn fmt2 implementations—
impl core::fmt::Debug for Either<L, R>—
impl core::fmt::Debug for IterEither<L, R>—

impl core::fmt::Display for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::LowerExp for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::LowerHex for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::Octal for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::Pointer for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::UpperExp for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::UpperHex for Either<L, R>

pub fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result—

impl core::fmt::Write for Either<L, R>

pub fn write_char(self: &mut Self, c: char) -> fmt::Result—
pub fn write_fmt(self: &mut Self, args: fmt::Arguments<'_>) -> fmt::Result—
pub fn write_str(self: &mut Self, s: &str) -> fmt::Result—

impl core::future::future::Future for Either<L, R>

pub fn poll(self: Pin<&mut Self>, cx: &mut core::task::Context<'_>) -> core::task::Poll<<Self as core::future::future::Future>::Output>—

impl core::hash::Hash for Either<L, R>

pub fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)—

impl core::io::seek::Seek for Either<L, R>

pub fn seek(self: &mut Self, pos: SeekFrom) -> io::Result<u64>—

impl core::io::write::Write for Either<L, R>

pub fn flush(self: &mut Self) -> io::Result<()>—
pub fn write(self: &mut Self, buf: &[u8]) -> io::Result<usize>—
pub fn write_all(self: &mut Self, buf: &[u8]) -> io::Result<()>—

impl core::iter::traits::collect::Extend<A> for Either<L, R>

pub fn extend<T>(self: &mut Self, iter: T) where T: IntoIterator<Item = A>—

impl core::iter::traits::collect::Extend<either::Either<L, R>> for (A, B)

pub fn extend<T>(self: &mut Self, iter: T) where T: IntoIterator<Item = Either<L, R>>—

impl core::iter::traits::collect::FromIterator<either::Either<L, R>> for (A, B)

pub fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item = Either<L, R>>—

impl core::iter::traits::double_ended::DoubleEndedIterator for …

fn next_back2 implementations1 claim
impl core::iter::traits::double_ended::DoubleEndedIterator for Either<L, R>1 claim
impl core::iter::traits::double_ended::DoubleEndedIterator for IterEither<L, R>—
fn nth_back2 implementations—
impl core::iter::traits::double_ended::DoubleEndedIterator for Either<L, R>—
impl core::iter::traits::double_ended::DoubleEndedIterator for IterEither<L, R>—
fn rfind2 implementations—
impl core::iter::traits::double_ended::DoubleEndedIterator for Either<L, R>—
impl core::iter::traits::double_ended::DoubleEndedIterator for IterEither<L, R>—
fn rfold2 implementations—
impl core::iter::traits::double_ended::DoubleEndedIterator for Either<L, R>—
impl core::iter::traits::double_ended::DoubleEndedIterator for IterEither<L, R>—

impl core::iter::traits::exact_size::ExactSizeIterator for …

fn len2 implementations—
impl core::iter::traits::exact_size::ExactSizeIterator for Either<L, R>—
impl core::iter::traits::exact_size::ExactSizeIterator for IterEither<L, R>—

impl core::iter::traits::iterator::Iterator for …

fn all2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn any2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn collect2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn count2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn find2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn find_map2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn fold2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn for_each2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn last2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn next2 implementations1 claim
impl core::iter::traits::iterator::Iterator for Either<L, R>1 claim
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn nth2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn partition2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn position2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—
fn size_hint2 implementations—
impl core::iter::traits::iterator::Iterator for Either<L, R>—
impl core::iter::traits::iterator::Iterator for IterEither<L, R>—

impl core::ops::deref::Deref for Either<L, R>

pub fn deref(self: &Self) -> &<Self as core::ops::deref::Deref>::Target—

impl core::ops::deref::DerefMut for Either<L, R>

pub fn deref_mut(self: &mut Self) -> &mut <Self as core::ops::deref::Deref>::Target—

impl either::IntoEither for T

pub fn into_either(self: Self, into_left: bool) -> Either<Self, Self>1 claim
pub fn into_either_with<F>(self: Self, into_left: F) -> Either<Self, Self> where F: FnOnce(&Self) -> bool1 claim

impl serde_core::de::Deserialize<'de> for Either<L, R>

pub fn deserialize<__D>(__deserializer: __D) -> _serde::__private228::Result<Self, <__D as serde_core::de::Deserializer>::Error> where __D: _serde::Deserializer<'de>—

impl serde_core::ser::Serialize for Either<L, R>

pub fn serialize<__S>(self: &Self, __serializer: __S) -> _serde::__private228::Result<<__S as serde_core::ser::Serializer>::Ok, <__S as serde_core::ser::Serializer>::Error> where __S: _serde::Serializer—

Blanket implementations

impl alloc::borrow::ToOwned for …

fn clone_into2 implementations—
impl alloc::borrow::ToOwned for Either<L, R>—
impl alloc::borrow::ToOwned for IterEither<L, R>—
fn to_owned2 implementations—
impl alloc::borrow::ToOwned for Either<L, R>—
impl alloc::borrow::ToOwned for IterEither<L, R>—

impl alloc::string::ToString for Either<L, R>

pub fn to_string(self: &Self) -> String—

impl core::any::Any for …

fn type_id2 implementations—
impl core::any::Any for Either<L, R>—
impl core::any::Any for IterEither<L, R>—

impl core::borrow::Borrow<T> for …

fn borrow2 implementations—
impl core::borrow::Borrow<T> for Either<L, R>—
impl core::borrow::Borrow<T> for IterEither<L, R>—

impl core::borrow::BorrowMut<T> for …

fn borrow_mut2 implementations—
impl core::borrow::BorrowMut<T> for Either<L, R>—
impl core::borrow::BorrowMut<T> for IterEither<L, R>—

impl core::clone::CloneToUninit for …

unsafe fn clone_to_uninit2 implementations—
unsafe impl core::clone::CloneToUninit for Either<L, R>—
unsafe impl core::clone::CloneToUninit for IterEither<L, R>—

impl core::convert::From<T> for …

fn from2 implementations—
impl core::convert::From<T> for Either<L, R>—
impl core::convert::From<T> for IterEither<L, R>—

impl core::convert::Into<U> for …

fn into2 implementations—
impl core::convert::Into<U> for Either<L, R>—
impl core::convert::Into<U> for IterEither<L, R>—

impl core::convert::TryFrom<U> for …

fn try_from2 implementations—
impl core::convert::TryFrom<U> for Either<L, R>—
impl core::convert::TryFrom<U> for IterEither<L, R>—

impl core::convert::TryInto<U> for …

fn try_into2 implementations—
impl core::convert::TryInto<U> for Either<L, R>—
impl core::convert::TryInto<U> for IterEither<L, R>—

impl core::future::into_future::IntoFuture for Either<L, R>

pub fn into_future(self: Self) -> <F as IntoFuture>::IntoFuture—

impl core::iter::traits::collect::IntoIterator for …

fn into_iter2 implementations—
impl core::iter::traits::collect::IntoIterator for Either<L, R>—
impl core::iter::traits::collect::IntoIterator for IterEither<L, R>—

impl either::IntoEither for …

fn into_either2 implementations—
impl either::IntoEither for Either<L, R>—
impl either::IntoEither for IterEither<L, R>—
fn into_either_with2 implementations—
impl either::IntoEither for Either<L, R>—
impl either::IntoEither for IterEither<L, R>—

Recorded callables

<core::result::Result<R, L> as From<either::Either<L, R>>>::from recorded callable · signature and safety not recorded1 claim
<either::Either as From<core::result::Result<R, L>>>::from recorded callable · signature and safety not recorded1 claim