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

// Construction syntax

syntax array_initialization from "<" Arg(<type>, type) ">[" [{Arg(<expr>, elems) "," [s]} Arg(<expr>, elems)] "]" {
    let res = arr<$type>();

    @elems.i {
        res.push($elems.i);
    }
    
    return move(res);
}

syntax list_comprehension from "[" [s] Arg(<expr>, map) s "for" s Arg(<ident>, it) [s] ":" [s] Arg(<type>, type) s "in" s Arg(<expr>, container) [s] "]" {
    let res = arr<$type>();
    let func = ($it: $type) -> $type $map;

    for _it_ in $container {
        res.push(func(*_it_));
    \}
    
    return move(res);
}

// Algorithms

fn<T> arr_with_capacity(size: Int) -> Array<'T> {
    let res = arr<'T>();
    res.reserve(move(size));
    
    return move(res);
}

fn<T> fill(array: @Array<'T>, value: 'T) -> @Array<'T> {
    while array.capacity() > array.len() {
        array.push(*value);
    }

    return array;
}

fn<T> fill_with(array: @Array<'T>, f: Int => 'T) -> @Array<'T> {
    let idx = array.len();

    while array.capacity() > array.len() {
        array.push(f(*idx));
        idx.inc();
    }

    return array;
}

fn<T, G> transform(array: @Array<'T>, f: 'T => 'G) -> Array<'G> {
    let res = arr_with_capacity<'G>(array.len());

    for i in array {
        res.push(f(*i));
    }

    return move(res);
}

fn<T> transform_inplace(array: @Array<'T>, f: 'T => 'T) -> @Array<'T> {
    for i in array {
        i := f(*i);
    }

    return array;
}

fn<T> reverse(array: @Array<'T>) -> @Array<'T> {
    let length = array.len();
    let half = length / 2;
    let i = 0;
    
    while i < half {
        swap(array[*i], array[length - i - 1]);
        i.inc();
    }

    return array;
}

fn<T> reduce(array: @Array<'T>, base: 'T, op: ('T, 'T) => 'T) -> 'T {
    for i in array {
        base := op(*base, *i);
    }

    return move(base);
}

// Printable interface

fn<T> print(array: Array<'T [Printable]>) {
    let idx = 0;

    print("[");

    for i in array {
        print(*i);

        idx.inc();

        if idx < array.len() {
            print(", ");
        }
    }

    print("]");
}

implement<T> Printable for Array<'T [Printable]>;