Enum Pair

pub enum Pair<L, R> {
    GivenLeft {
        left: L,
        right_cell: OnceCell<R>,
    },
    GivenRight {
        left_cell: OnceCell<L>,
        right: R,
    },
}

A pair of values where one can be converted to the other.

Example

use cached_pair::Pair;

// Construct a pair from a left value.
let pair: Pair<i32, String> = Pair::from_left(42);

// Left value is present, but right value is not.
assert_eq!(pair.left_opt(), Some(&42));
assert_eq!(pair.right_opt(), None);

// Get a right value by converting the left value.
assert_eq!(pair.right_with(|l| l.to_string()), "42");

// Once we get the right value, it is cached.
assert_eq!(pair.right_opt(), Some(&"42".to_string()));

// mutable access
let mut pair = pair;

// Get a mutable reference to the left value.
*pair.left_opt_mut().unwrap() = 123;

// ...then the right value is cleared.
assert_eq!(pair.right_opt(), None);

Variants

GivenLeft

Fields

left: L

right_cell: OnceCell<R>

GivenRight

Fields

left_cell: OnceCell<L>

right: R

Implementations

impl<L, R> Pair<L, R>

pub fn from_left(left: L) -> Self

Constructs a pair from a left value.

pub fn from_right(right: R) -> Self

Constructs a pair from a right value.

pub fn left_with<'a, F: FnOnce(&'a R) -> L>(&'a self, f: F) -> &'a L

Returns the left value. If the left value is not available, it converts the right value using the given closure.

pub fn right_with<'a, F: FnOnce(&'a L) -> R>(&'a self, f: F) -> &'a R

Returns the right value. If the right value is not available, it converts the left value using the given closure.

pub fn try_left_with<'a, F: FnOnce(&'a R) -> Result<L, E>, E>( &'a self, f: F, ) -> Result<&'a L, E>

Returns the left value. If the left value is not available, it converts the right value using the given closure.

pub fn try_right_with<'a, F: FnOnce(&'a L) -> Result<R, E>, E>( &'a self, f: F, ) -> Result<&'a R, E>

Returns the right value. If the right value is not available, it converts the left value using the given closure.

pub fn left_mut_with<F: for<'a> FnOnce(&'a R) -> L>(&mut self, f: F) -> &mut L

Returns the left value as a mutable reference. If the left value is not available, it converts the right value using the given closure.

pub fn right_mut_with<F: for<'a> FnOnce(&'a L) -> R>(&mut self, f: F) -> &mut R

Returns the right value as a mutable reference. If the right value is not available, it converts the left value using the given closure.

pub fn try_left_mut_with<F: for<'a> FnOnce(&'a R) -> Result<L, E>, E>( &mut self, f: F, ) -> Result<&mut L, E>

Returns the left value as a mutable reference. If the left value is not available, it converts the right value using the given closure.

pub fn try_right_mut_with<F: for<'a> FnOnce(&'a L) -> Result<R, E>, E>( &mut self, f: F, ) -> Result<&mut R, E>

Returns the right value as a mutable reference. If the right value is not available, it converts the left value using the given closure.

pub fn left_opt(&self) -> Option<&L>

Returns the left value if it is available. Otherwise, returns None.

pub fn right_opt(&self) -> Option<&R>

Returns the right value if it is available. Otherwise, returns None.

pub fn left_opt_mut(&mut self) -> Option<&mut L>

Returns a left value if it is available. If the left value is available, this method clears the right value.

pub fn right_opt_mut(&mut self) -> Option<&mut R>

Returns a right value if it is available. If the right value is available, this method clears the left value.

pub fn left<'a>(&'a self) -> &'a L

where &'a R: Into<L>,

Returns a left value if it is available. If the left value is not available, it uses the Into trait to convert the right value.

pub fn right<'a>(&'a self) -> &'a R

where &'a L: Into<R>,

Returns a right value if it is available. If the right value is not available, it uses the Into trait to convert the left value.

pub fn try_left<'a, E>(&'a self) -> Result<&'a L, E>

where &'a R: TryInto<L, Error = E>,

Returns a left value if it is available. If the left value is not available, it uses the TryInto trait to convert the right value.

pub fn try_right<'a, E>(&'a self) -> Result<&'a R, E>

where &'a L: TryInto<R, Error = E>,

Returns a right value if it is available. If the right value is not available, it uses the TryInto trait to convert the left value.

pub fn into_left_with<F: FnOnce(R) -> L>(self, f: F) -> L

Consumes the pair and turn it into a left value.

pub fn into_right_with<F: FnOnce(L) -> R>(self, f: F) -> R

Consumes the pair and turn it into a right value.

pub fn try_into_left_with<F: FnOnce(R) -> Result<L, E>, E>( self, f: F, ) -> Result<L, E>

Consumes the pair and turn it into a left value.

pub fn try_into_right_with<F: FnOnce(L) -> Result<R, E>, E>( self, f: F, ) -> Result<R, E>

Consumes the pair and turn it into a right value.

pub fn into_left(self) -> L

where R: Into<L>,

Consumes the pair and turn it into a left value, using From<R> if it’s needed.

pub fn into_right(self) -> R

where L: Into<R>,

Consumes the pair and turn it into a right value, using From<L> if it’s needed.

pub fn try_into_left<E>(self) -> Result<L, E>

where R: TryInto<L, Error = E>,

Consumes the pair and turn it into a left value, using TryInto<L> if it’s needed.

pub fn try_into_right<E>(self) -> Result<R, E>

where L: TryInto<R, Error = E>,

Consumes the pair and turn it into a right value, using TryInto<R> if it’s needed.

pub fn as_ref(&self) -> EitherOrBoth<&L, &R>

Returns a reference to the pair as itertools::EitherOrBoth.

Trait Implementations

impl<L: Clone, R: Clone> Clone for Pair<L, R>

fn clone(&self) -> Pair<L, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for Pair<L, R>

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

Formats the value using the given formatter.

impl<L, R> From<Pair<L, R>> for EitherOrBoth<L, R>

fn from(pair: Pair<L, R>) -> Self

Converts to this type from the input type.

impl<L: Hash, R: Hash> Hash for Pair<L, R>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L: PartialEq, R: PartialEq> PartialEq for Pair<L, R>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<L: Eq, R: Eq> Eq for Pair<L, R>