erg_compiler 0.6.53

Centimetre: the Erg compiler
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

# TODO: transition specifications
array = pyimport "List"

.List!: ClassType
.List! <: array.List
.List!.
    '''
    Append object to the end of the list.
    '''
    '''erg
    arr = ![1, 2]
    arr.push! 3
    assert arr == [1, 2, 3]
    '''
    push!: |T, N: Nat|(self: List!(T, N), elem: T) => NoneType
    '''
    Extend the list by appending all the items from `iterable`.
    '''
    '''erg
    arr = ![1, 2]
    arr.extend! [3, 4]
    assert arr == [1, 2, 3, 4]
    '''
    extend!: |T, N: Nat|(self: List!(T, N), iterable: Iterable(T)) => NoneType
    '''
    Insert `elem` before `index`.
    '''
    '''erg
    arr = ![1, 2]
    arr.insert! 0, 3
    assert arr == [3, 1, 2]
    '''
    insert!: |T, N: Nat|(self: List!(T, N), index: Nat, elem: T) => NoneType
    '''
    Remove the first item from the list whose value is `value`.
    '''
    '''erg
    arr = ![1, 2]
    arr.remove! 1
    assert arr == [2]
    '''
    remove!: |T, N: Nat|(self: List!(T, N), value: T) => NoneType
    '''
    Remove the item at the given position in the list, and return it.
    '''
    '''erg
    arr = ![1, 2]
    i = arr.pop!()
    assert arr == [1]
    assert i == 2
    '''
    pop!: |T, N: Nat|(self: List!(T, N), index := Nat or {-1}) => T
    '''
    Remove all items from the list.
    '''
    '''erg
    arr = ![1, 2]
    arr.clear!()
    assert arr == []
    '''
    clear!: |T, N: Nat|(self: List!(T, N)) => NoneType
    '''
    Sort the list in ascending order and return `None`.

    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
    order of two equal elements is maintained).

    If a `key` function is given, apply it once to each list item and sort them,
    ascending or descending, according to their function values.

    The `reverse` flag can be set to sort in descending order.
    '''
    '''erg
    arr = ![3, 1, 2]
    arr.sort!()
    assert arr == [1, 2, 3]
    '''
    sort!: |T, N: Nat|(self: List!(T, N)) => NoneType
    '''
    Reverse the elements of the list in-place and return `None`.
    '''
    '''erg
    arr = ![3, 1, 2]
    arr.reverse!()
    assert arr == [2, 1, 3]
    '''
    reverse!: |T, N: Nat|(self: List!(T, N)) => NoneType
    '''
    Update each element of the array according to the passed function `f`.
    '''
    '''erg
    arr = ![1, 2]
    arr.strict_map! x -> x + 1
    assert arr == [3, 4]
    '''
    strict_map!: |T, N: Nat|(self: List!(T, N), f: T -> T) => NoneType
    '''
    Update `index`-th element of the array according to the passed function `f`.
    '''
    '''erg
    arr = ![1, 2]
    arr.udpate_nth! 0, x -> x + 1
    assert arr == [2, 2]
    '''
    update_nth!: |T, N: Nat|(self: List!(T, N), index: Nat, f: T -> T) => NoneType
    '''
    Return a (deep) copy of the array.
    '''
    '''erg
    arr = ![1, 2]
    arr_copy = arr.copy()
    arr_copy.push! 3
    assert arr_copy == [1, 2, 3]
    assert arr == [1, 2]
    '''
    copy: |T, N: Nat|(self: Ref(List!(T, N))) => List!(T, N)