aboutsummaryrefslogtreecommitdiff
path: root/stdlib.slip
blob: 2568354bf8ceed68f39ab24e4f6d2dcdb006fa27 (plain)
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

(let discard
  (fn a T Nil ())
)

(let if
  (fn (cond iftrue iffalse) (Bool T T) T
    (case cond
      (true iftrue)
      (_ iffalse))
  )
)


(let ++
  (fn x Int Int
    (+ x 1)
  )
)


(let --
  (fn x Int Int
    (- x 1)
  )
)


(let sum (fix
  (fn sum' ((Vector (Int ...)) -> Int)
           ((Vector (Int ...)) -> Int)
    (fn vec (Vector (Int ...)) Int
      (case vec
        ((h ..t) (+ h (sum' t)))
        (_ 0))
    )
  )
))


(let map-i->i (fix
  (fn map'       (((Vector (Int ...)) (Int -> Int)) -> (Vector (Int ...)))
                 (((Vector (Int ...)) (Int -> Int)) -> (Vector (Int ...)))
    (fn (vec fun) ((Vector (Int ...)) (Int -> Int)) (Vector (Int ...))
      (case vec
      ((h ..t) (<> (vector (fun h)) (map' t fun)))
      (_ (() Int)))
    )
  )
))


(let filter-int (fix
  (fn filter'     (((Vector (Int ...)) (Int -> Bool)) -> (Vector (Int ...)))
                  (((Vector (Int ...)) (Int -> Bool)) -> (Vector (Int ...)))
    (fn (vec pred) ((Vector (Int ...)) (Int -> Bool)) (Vector (Int ...))
      (case vec
        ((h ..t) (
	    if (pred h)
	      (<> (vector h) (filter' t pred))
	      (filter' t pred))
	)
        (_ (() Int))
      )
    )
  )
))


(let repeat
  (fn (fun n) ((Int -> Nil) Int) Nil

    ((let repeat-inner (fix
      (fn repeat-inner'      (((Int -> Nil) Int Int) -> Nil)
                             (((Int -> Nil) Int Int) -> Nil)
        (fn (fun index until) ((Int -> Nil) Int Int)    Nil
	  (case (<= index until)
	    (true (discard (fun index) (repeat-inner' fun (++ index) until)))
            (_ ()))
	)
      )
    ))

    (repeat-inner fun 1 n))
  )
)


(let left-or
  (fn (sum def) ((Sum L R) L) L
    (case sum
      ((inl x) x)
      (_ def))
  )
)


(let right-or
  (fn (sum def) ((Sum L R) R) R
    (case sum
      ((inr x) x)
      (_ def))
  )
)