Joseph Ferano
7f86f32699
The spike proved the shape; this makes it the feature. A generic body is
still checked abstractly once, but now it may be told what to assume:
{:where (ordered? $t)} at the head of the body, Clojure's {:pre [...]}
spelling, with five predicates - ordered?, equal?, hashable?, numeric?
and copyable?.
The syntax catch settled structurally: {K V} is still a legal return
type, and a constraint map is told from one by its leading keyword. A
keyword is not a type anywhere in the language, so the slot after the
return type is unambiguous and {K V} did not have to go.
A type variable is move-only by default, with copyable? the opt-out.
Move is the stricter rule, so assuming it can only refuse a valid
program, never admit a bad one. That is Rust's T: Copy and not Odin's
anything - Odin has no move semantics at all.
The runaway refusal no longer names a depth. It names the chain: a
generic already on the instantiation stack, asked for again at a type
built around the one it had before, is growing and will not stop.
54 lines
1.4 KiB
Plaintext
54 lines
1.4 KiB
Plaintext
;; Which of prelude.ml's per-type families collapse as they are written, and
|
|
;; which need their signature changed. Nothing here is installed in the
|
|
;; prelude; it is the same bodies, over $t, checked and run.
|
|
|
|
(defn keep [s [$t] keep? (Fn [$t] bool)] (Vec $t)
|
|
{:where (copyable? $t)}
|
|
(let [v (vec-new t)]
|
|
(dotimes [i (len s)]
|
|
(when (keep? (at s i))
|
|
(push v (at s i))))
|
|
v))
|
|
|
|
(defn apply! [s [$t] f (Fn [$t] $t)] ()
|
|
(dotimes [i (len s)]
|
|
(set (at s i) (f (at s i)))))
|
|
|
|
(defn fold [s [$t] init $t f (Fn [$t $t] $t)] t
|
|
{:where (copyable? $t)}
|
|
(let [acc init]
|
|
(dotimes [i (len s)]
|
|
(set acc (f acc (at s i))))
|
|
acc))
|
|
|
|
(defn flip! [s [$t]] ()
|
|
(let [i 0
|
|
j (- (len s) 1)]
|
|
(while (< i j)
|
|
(let [tmp (at s i)]
|
|
(set (at s i) (at s j))
|
|
(set (at s j) tmp))
|
|
(set i (+ i 1))
|
|
(set j (- j 1)))))
|
|
|
|
(defvar ns [5 i32])
|
|
(defvar fs [5 f32])
|
|
|
|
(defn main [] ()
|
|
(let [xs (slice ns 0 5)
|
|
ys (slice fs 0 5)]
|
|
(dotimes [i 5]
|
|
(set (at xs i) (+ i 1))
|
|
(set (at ys i) (f32 (* 2 (+ i 1)))))
|
|
(apply! xs (fn [x] (* x 10)))
|
|
(apply! ys (fn [x] (* x (f32 2))))
|
|
(flip! xs)
|
|
(flip! ys)
|
|
(println (fold xs 0 (fn [a b] (+ a b))))
|
|
(println (fold ys (f32 0) (fn [a b] (+ a b))))
|
|
(let [evens (keep xs (fn [x] (= (% x 20) 0)))]
|
|
(println (len evens))
|
|
(free evens))
|
|
(println (at xs 0))
|
|
(println (at ys 0))))
|