Trait higher::functor::Functor

pub trait Functor<'a, A: 'a> {
    type Target<T: 'a>: Functor<'a, T, Target<A> = Self>;

    fn fmap<B: 'a, F>(self, f: F) -> Self::Target<B>
    where
        F: Fn(A) -> B + 'a;

    fn fconst<B>(self, b: B) -> Self::Target<B>
    where
        Self: Sized,
        B: Clone,
    { ... }
    fn void(self) -> Self::Target<()>
    where
        Self: Sized,
    { ... }
    fn f_into_iter(self) -> Box<dyn Iterator<Item = A>>
    where
        Self: Sized,
        A: 'static,
    { ... }
}

A Functor lets you change the type parameter of a generic type.

A Functor defines a method fmap on a type F<_>: Functor which converts an F<A> to F<B> using a function Fn(A) -> B applied to the As inside it.

You can also use this just to modify the values inside your container value without changing their type, if the mapping function returns a value of the same type. This is called an “endofunctor.” In an ideal Rust, we would be able to implement this as a special case of fmap modifying the data in place, but in the Rust we have, beware that using fmap in this manner is considerably less efficient than using a mutable reference iterator.

Required Associated Types

type Target<T: 'a>: Functor<'a, T, Target<A> = Self>

Required Methods

fn fmap<B: 'a, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> B + 'a,

Map a functor of A to a functor of B using a function from A to B.

Provided Methods

fn fconst<B>(self, b: B) -> Self::Target<B>where
    Self: Sized,
    B: Clone,

Map the functor to the provided constant value.

fn void(self) -> Self::Target<()>where
    Self: Sized,

Map the functor to the unit value ().

fn f_into_iter(self) -> Box<dyn Iterator<Item = A>>where
    Self: Sized,
    A: 'static,

Turn the functor into an iterator.

let my_functor = vec![1, 2, 3];
let iter = my_functor.f_into_iter();
let my_vec: Vec<i32> = iter.collect();
assert_eq!(my_vec, vec![1, 2, 3]);

Implementations on Foreign Types

impl<'a, A: 'a> Functor<'a, A> for Option<A>

type Target<T: 'a> = Option<T>

fn fmap<B: 'a, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> B,

impl<'a, A: 'a, E> Functor<'a, A> for Result<A, E>

type Target<T: 'a> = Result<T, E>

fn fmap<B, F>(self, f: F) -> Self::Target<B>where
    B: 'a,
    F: Fn(A) -> B,

impl<'a, A: 'a, const N: usize> Functor<'a, A> for [A; N]

type Target<T: 'a> = [T; N]

fn fmap<B, F>(self, f: F) -> Self::Target<B>where
    B: 'a,
    F: Fn(A) -> B + 'a,

impl<'a, A: 'a> Functor<'a, A> for Vec<A>

type Target<T: 'a> = Vec<T, Global>

fn fmap<B, F>(self, f: F) -> Self::Target<B>where
    B: 'a,
    F: Fn(A) -> B,

impl<'a, A: 'a> Functor<'a, A> for VecDeque<A>

type Target<T: 'a> = VecDeque<T, Global>

fn fmap<B, F>(self, f: F) -> Self::Target<B>where
    B: 'a,
    F: Fn(A) -> B,

impl<'a, A: 'a> Functor<'a, A> for LinkedList<A>

type Target<T: 'a> = LinkedList<T>

fn fmap<B, F>(self, f: F) -> Self::Target<B>where
    B: 'a,
    F: Fn(A) -> B,

Implementors