gluon 0.18.2

A static, type inferred programming language for application embedding
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

//@NO-IMPLICIT-PRELUDE
//! Implementation of the `Traversable` type

let { Functor } = import! std.functor
let { Foldable } = import! std.foldable
let { Applicative } = import! std.applicative

#[implicit]
type Traversable t = {
    functor : Functor t,
    foldable : Foldable t,
    traverse : forall a b m . Applicative m -> (a -> m b) -> t a -> m (t b)
}

let traverse ?t ?a : forall a b m .
        [Traversable t]
            -> [Applicative m]
            -> (a -> m b)
            -> t a
            -> m (t b)
    =
    t.traverse a

let sequence : [Traversable t] -> [Applicative m] -> t (m a) -> m (t a) =
    traverse (\x -> x)

let for x f : [Traversable t] -> [Applicative m] -> t a -> (a -> m b) -> m (t b) =
    traverse f x


{
    Traversable,

    traverse,
    sequence,
    for,
}