Trait naan::functor::Functor

pub trait Functor<F, A>where
    F: HKT1<T<A> = Self>,{
    // Required method
    fn fmap<AB, B>(self, f: AB) -> F::T<B>
       where AB: F1<A, Ret = B>;
}

Functor adds a mapping operation to generic types.

In essence, map allows one to lift a function of type fn(A) -> B to some new Functor context, e.g. fn(Option<A>) -> Option<B>.

Laws

• Invoking map with an identity function (e.g. |a| a) should do absolutely nothing.

use naan::prelude::*;

#[derive(Debug, PartialEq, Eq)]
struct Container<T>(T);
struct ContainerHKT;
impl HKT1 for ContainerHKT {
  type T<A> = Container<A>;
}

impl<A> Functor<ContainerHKT, A> for Container<A> {
  fn fmap<AB, B>(self, f: AB) -> Container<B>
    where AB: F1<A, Ret = B>
  {
    Container(f.call(self.0))
  }
}

assert_eq!(Container(0u8).fmap(|n| n + 1).fmap(|n: u8| n.to_string()),
           Container("1".to_string()))

Required Methods

fn fmap<AB, B>(self, f: AB) -> F::T<B>where AB: F1<A, Ret = B>,

Use a function from A -> B to transform an F<A> to an F<B>.

Implementations on Foreign Types

impl<A, E> Functor<ResultOk<E>, A> for Result<A, E>

fn fmap<AB, B>(self, f: AB) -> <ResultOk<E> as HKT1>::T<B>where AB: F1<A, Ret = B>,

impl<A> Functor<Vec, A> for Vec<A>

fn fmap<AB, B>(self, f: AB) -> Vec<B>where AB: F1<A, Ret = B>,

impl<K, A> Functor<BTreeMapValues<K>, A> for BTreeMap<K, A>where K: Ord,

fn fmap<AB, B>(self, f: AB) -> BTreeMap<K, B>where AB: F1<A, Ret = B>,

impl<A> Functor<Option, A> for Option<A>

fn fmap<AB, B>(self, f: AB) -> <Option as HKT1>::T<B>where AB: F1<A, Ret = B>,

impl<const N: usize, A> Functor<ArrayVec<N>, A> for ArrayVec<[Option<A>; N]>

fn fmap<AB, B>(self, f: AB) -> ArrayVec<[Option<B>; N]>where AB: F1<A, Ret = B>,

impl<K, A> Functor<HashMapValues<K>, A> for HashMap<K, A>where K: Hash + Eq,

fn fmap<AB, B>(self, f: AB) -> HashMap<K, B>where AB: F1<A, Ret = B>,

Implementors

impl<A> Functor<Id, A> for Id<A>

impl<M, T, A> Functor<JoinHKT<M>, A> for Join<M, T, A>where JoinHKT<M>: HKT1<T<A> = Self>, M: HKT2 + HKT2<T<A, A> = T>, T: Bifunctor<M, A, A>,