Trait Invariant

pub trait Invariant<B>: Higher {
    // Required method
    fn imap<F, G>(self, f: F, g: G) -> Self::Target<B>
       where F: FnMut(Self::Param) -> B,
             G: FnMut(B) -> Self::Param;
}

Invariant functor (also known as exponential functor).

Required Methods

fn imap<F, G>(self, f: F, g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

Transform a Self<A> into a Self<B> by providing a transformation from A to B and one from B to A.

Examples

use rust2fun::prelude::*;

let x = Some("1".to_string());
let actual = x.imap(|s| s.parse::<i32>().unwrap(), |i| i.to_string());
assert_eq!(Some(1), actual);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A, B> Invariant<B> for PhantomData<A>

fn imap<F, G>(self, _f: F, _g: G) -> PhantomData<B>

where F: FnMut(A) -> B, G: FnMut(B) -> A,

impl<A, B, K: Hash + Eq> Invariant<B> for HashMap<K, A>

fn imap<F, G>(self, f: F, _g: G) -> HashMap<K, B>

where F: FnMut(A) -> B, G: FnMut(B) -> A,

impl<B, T> Invariant<B> for Option<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B, T> Invariant<B> for Box<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B, T> Invariant<B> for LinkedList<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B, T> Invariant<B> for VecDeque<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B, T> Invariant<B> for Vec<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B, T, E> Invariant<B> for Result<T, E>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B: Ord, T> Invariant<B> for BinaryHeap<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B: Ord, T> Invariant<B> for BTreeSet<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

impl<B: Hash + Eq, T> Invariant<B> for HashSet<T>

fn imap<F, G>(self, f: F, _g: G) -> Self::Target<B>

where F: FnMut(Self::Param) -> B, G: FnMut(B) -> Self::Param,

Implementors

impl<B, T> Invariant<B> for NEVec<T>

impl<B, T, E> Invariant<B> for Validated<T, E>