higher-cat 0.1.1

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
use std::hash::{BuildHasher, Hash};
use std::iter;

/// `Pure` lets you construct a value of type `F<A>` using a single value of
/// `A`.
pub trait Pure<A> {
    fn pure(value: A) -> Self;
}

impl<A> Pure<A> for Option<A> {
    fn pure(value: A) -> Self {
        Some(value)
    }
}

impl<A, E> Pure<A> for Result<A, E> {
    fn pure(value: A) -> Self {
        Ok(value)
    }
}

impl<A> Pure<A> for Vec<A> {
    fn pure(value: A) -> Self {
        vec![value]
    }
}

impl<A> Pure<A> for VecDeque<A> {
    fn pure(value: A) -> Self {
        iter::once(value).collect()
    }
}

impl<A> Pure<A> for LinkedList<A> {
    fn pure(value: A) -> Self {
        iter::once(value).collect()
    }
}

impl<A> Pure<A> for BinaryHeap<A>
where
    A: Ord,
{
    fn pure(value: A) -> Self {
        iter::once(value).collect()
    }
}

impl<A> Pure<A> for BTreeSet<A>
where
    A: Ord,
{
    fn pure(value: A) -> Self {
        iter::once(value).collect()
    }
}

impl<A, S> Pure<A> for HashSet<A, S>
where
    A: Hash + Eq,
    S: BuildHasher + Default,
{
    fn pure(value: A) -> Self {
        iter::once(value).collect()
    }
}

impl<A, B> Pure<(A, B)> for BTreeMap<A, B>
where
    A: Ord,
    B: Ord,
{
    fn pure(value: (A, B)) -> Self {
        iter::once(value).collect()
    }
}

impl<A, B, S> Pure<(A, B)> for HashMap<A, B, S>
where
    A: Hash + Eq,
    B: Hash + Eq,
    S: BuildHasher + Default,
{
    fn pure(value: (A, B)) -> Self {
        iter::once(value).collect()
    }
}