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.