regulus 0.0.14

A simple, interpreted language with very simple syntax and zero dependencies
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

# update the `stl_import_shadowing` test if the following line changes
import(range),

# reference implementation:
# fn quicksort<T: PartialOrd + Copy>(mut seq: Vec<T>) -> Vec<T> {
#     if seq.len() >= 2 {
#         let pivot_idx = seq.len() / 2;
#         let pivot = seq[pivot_idx];
#         let mut left = Vec::new();
#         let mut right = Vec::new();
#         for i in 0..seq.len() {
#             if pivot_idx != i {
#                 let el = seq[i];
#                 if el <= pivot {
#                     left.push(el);
#                 } else {
#                     right.push(el);
#                 }
#             }
#         }
#         left = quicksort(left);
#         right = quicksort(right);
#         let step = left.len();
#         for i in 0..step {
#             seq[i] = left[i];
#         }
#         seq[step] = pivot;
#         for i in 0..right.len() {
#             seq[i + 1 + step] = right[i];
#         }
#     }
#     seq
# }
def(quicksort, seq, _(
    =(l, len(seq)),
    if(>=(l, 2), _(
        =(pivot_idx, /(l, 2)),
        =(pivot, index(seq, pivot_idx)),
        =(left, list()),
        =(right, list()),
        for_in(range(0, l), i, _(
            if(!=(pivot_idx, i), _(
                =(el, index(seq, i)),
                ifelse(
                    <=(el, pivot),
                    =(left, append(left, el)),
                    =(right, append(right, el)),
                )
            ))
        )),
        =(left, quicksort(left)),
        =(right, quicksort(right)),
        =(step, len(left)),
        for_in(
            range(0, step),
            i,
            =(seq, replace_at(seq, i, index(left, i)))
        ),
        =(seq, replace_at(seq, step, pivot)),
        for_in(
            range(0, len(right)),
            i,
            =(seq, replace_at(
                seq,
                +(+(i, 1), step),
                index(right, i)
            ))
        ),
    )),
    seq
)),

# Returns whether the given sequence is sorted in ascending order.
def(is_sorted, seq, _(
    =(s, true),
    if(>=(len(seq), 2),
        for_in(range(0, -(len(seq), 1)), i, _(
            if(
                >(index(seq, i), index(seq, +(i, 1))),
                =(s, false)
            )
        )),
    ),
    s
)),