higher 0.2.0

Functors, Applicatives, Monads and other bad ideas
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use core::convert::identity;

/// A `Profunctor` is just a `Bifunctor` that is contravariant over its first
/// argument and covariant over its second argument. What's the problem?
pub trait Profunctor<'a, B, C> {
    type Target<T, U>;

    /// Map a function over both arguments of the profunctor.
    fn dimap<A, D, L, R>(self, left: L, right: R) -> Self::Target<A, D>
    where
        L: Fn(A) -> B + 'a,
        R: Fn(C) -> D + 'a;

    /// Map a function over the contravariant first argument only.
    fn lcmap<A, L>(self, left: L) -> Self::Target<A, C>
    where
        Self: Sized,
        C: 'a,
        L: Fn(A) -> B + 'a,
    {
        self.dimap(left, identity)
    }

    /// Map a function over the covariant second argument only.
    fn rmap<D, R>(self, right: R) -> Self::Target<B, D>
    where
        Self: Sized,
        B: 'a,
        R: Fn(C) -> D + 'a,
    {
        self.dimap(identity, right)
    }
}