cached-pair

A simple library for caching pairs of values. Similar to EitherOrBoth in the itertools crate, but with an extra assumption that both values are convertible to each other, and the conversion may be non-trivial or expensive.

For example, you can use this library to hold a pair of values that need to be kept in sync, such as a number and its string representation, or a binary Vec<u8> and its base64 encoded String.

Examples

Basic Usage with the Converter

You can define a converter between the two types, and use it to create a Pair.

use cached_pair::{Pair, Converter};
use std::convert::Infallible;
use std::num::ParseIntError;

// Define a converter between i32 and String
#[derive(Clone)]
struct MyConverter;

impl Converter<i32, String> for MyConverter {
    type ToLeftError<'a> = ParseIntError;
    type ToRightError<'a> = Infallible;

    fn convert_to_right(&self, left: &i32) -> Result<String, Self::ToRightError<'_>> {
        Ok(left.to_string())
    }

    fn convert_to_left(&self, right: &String) -> Result<i32, Self::ToLeftError<'_>> {
        right.parse()
    }
}

// Create a pair with a custom converter
let pair = Pair::from_left_conv(42, MyConverter);

// Access values
assert_eq!(pair.left_opt(), Some(&42));
assert_eq!(pair.try_right(), Ok(&"42".to_string()));

// The converted value is now cached
assert_eq!(pair.right_opt(), Some(&"42".to_string()));

Using Function Converters

You can also use the fn_converter function to create a converter from closures.

use cached_pair::{Pair, fn_converter};
use std::convert::Infallible;

// Create a converter using closures
let converter = fn_converter(
    |s: &String| Ok::<i32, _>(s.parse()?),
    |i: &i32| Ok::<String, Infallible>(i.to_string()),
);

let pair = Pair::from_left_conv(42, converter);
assert_eq!(pair.try_right(), Ok(&"42".to_string()));