nessa-language 0.9.1

An extensible programming language with a strong type system
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

/*
    MAP ITERATOR
*/

class MapIterator<It, Elem, Trf> {
    iter: 'It [Iterable<'It, 'Elem>];
    f: 'Elem => 'Trf;
}

fn<It, Elem, Trf> iterator(it: MapIterator<'It, 'Elem, 'Trf>) -> MapIterator<'It, 'Elem, 'Trf> {
    return *it;
}

fn<It, Elem, Trf> next(it: @MapIterator<'It, 'Elem, 'Trf>) -> 'Trf {
    let fnc = it.f;
    return fnc(it.iter.next());
}

fn<It, Elem, Trf> is_consumed(it: @MapIterator<'It, 'Elem, 'Trf>) -> Bool {
    return it.iter.is_consumed();
}

fn<Cont, It, Elem, Trf> map(it: 'Cont [Iterable<'It, 'Elem>], f: 'Elem => 'Trf) -> MapIterator<'It, 'Elem, 'Trf> {
    return MapIterator(iterator(move(it)), move(f));
}

implement<It, Elem, Trf> Iterable<MapIterator<'It, 'Elem, 'Trf>, 'Trf> for MapIterator<'It, 'Elem, 'Trf>;

/*
    FILTER ITERATOR
*/

class FilterIterator<It, Elem> {
    iter: 'It [Iterable<'It, 'Elem>];
    f: 'Elem => Bool;
    curr: 'Elem;
    consumed: Bool;
}

fn<It, Elem> advance_till_true(it: @FilterIterator<'It, 'Elem>) {
    let fnc = it.f;
    let iter_i = it.iter;

    while !iter_i.is_consumed() {
        it.curr = iter_i.next();

        if fnc(*it.curr) {
            return;
        }
    }
    
    it.consumed = true;
}

fn<It, Elem> iterator(it: FilterIterator<'It, 'Elem>) -> FilterIterator<'It, 'Elem> {
    return *it;
}

fn<It, Elem> next(it: @FilterIterator<'It, 'Elem>) -> 'Elem {    
    let res = *it.curr;

    if it.iter.is_consumed() {
        it.consumed = true;
    }

    it.advance_till_true();

    return *res;
}

fn<It, Elem> is_consumed(it: @FilterIterator<'It, 'Elem>) -> Bool {
    return it.iter.is_consumed() && it.consumed;
}

fn<Cont, It, Elem> filter(it: 'Cont [Iterable<'It, 'Elem>], f: 'Elem => Bool) -> FilterIterator<'It, 'Elem> {
    let iter_i = iterator(move(it));
    let res = FilterIterator(move(iter_i), *f, iter_i.next(), false);

    if !f(*res.curr) {
        res.advance_till_true();
    }

    return *res;
}

implement<It, Elem> Iterable<FilterIterator<'It, 'Elem>, 'Elem> for FilterIterator<'It, 'Elem>;

// Terminal operators

fn<It> sum(it: 'It [Iterable<'It, Int>]) -> Int {
    let res = 0;

    for i in move(it) {
        res := res + i;
    }

    return move(res);
}

fn<It> sum(it: 'It [Iterable<'It, Float>]) -> Float {
    let res = 0;

    for i in *it {
        res := res + i;
    }

    return *res;
}

fn<It, Elem> reduce(it: 'It [Iterable<'It, 'Elem>], op: ('Elem, 'Elem) => 'Elem, start: 'Elem) -> 'Elem {
    let res = move(start);

    for i in *it {
        res := op(*res, *i);
    }

    return *res;
}

fn<It> count(it: 'It [Iterable<'It, Int>]) -> Int {
    let res = 0;

    for i in move(it) {
        res.inc();
    }

    return move(res);
}