/
Traversable.purs
62 lines (55 loc) · 1.99 KB
/
Traversable.purs
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
module Data.Semigroup.Traversable where
import Prelude
import Data.Monoid.Dual (Dual(..))
import Data.Monoid.Multiplicative (Multiplicative(..))
import Data.Semigroup.Foldable (class Foldable1)
import Data.Traversable (class Traversable)
-- | `Traversable1` represents data structures with a minimum of one element that can be _traversed_,
-- | accumulating results and effects in some `Applicative` functor.
-- |
-- | - `traverse1` runs an action for every element in a data structure,
-- | and accumulates the results.
-- | - `sequence1` runs the actions _contained_ in a data structure,
-- | and accumulates the results.
-- |
-- | The `traverse1` and `sequence1` functions should be compatible in the
-- | following sense:
-- |
-- | - `traverse1 f xs = sequence1 (f <$> xs)`
-- | - `sequence1 = traverse1 identity`
-- |
-- | `Traversable1` instances should also be compatible with the corresponding
-- | `Foldable1` instances, in the following sense:
-- |
-- | - `foldMap1 f = runConst <<< traverse1 (Const <<< f)`
-- |
-- | Default implementations are provided by the following functions:
-- |
-- | - `traverse1Default`
-- | - `sequence1Default`
class (Foldable1 t, Traversable t) <= Traversable1 t where
traverse1 :: forall a b f. Apply f => (a -> f b) -> t a -> f (t b)
sequence1 :: forall b f. Apply f => t (f b) -> f (t b)
instance traversableDual :: Traversable1 Dual where
traverse1 f (Dual x) = Dual <$> f x
sequence1 = sequence1Default
instance traversableMultiplicative :: Traversable1 Multiplicative where
traverse1 f (Multiplicative x) = Multiplicative <$> f x
sequence1 = sequence1Default
-- | A default implementation of `traverse1` using `sequence1`.
traverse1Default
:: forall t a b m
. Traversable1 t
=> Apply m
=> (a -> m b)
-> t a
-> m (t b)
traverse1Default f ta = sequence1 (f <$> ta)
-- | A default implementation of `sequence1` using `traverse1`.
sequence1Default
:: forall t a m
. Traversable1 t
=> Apply m
=> t (m a)
-> m (t a)
sequence1Default = traverse1 identity