51 lines
2.0 KiB
Plaintext
51 lines
2.0 KiB
Plaintext
;; The prelude's function-taking family: map!, filter, reduce and a comparator
|
|
;; sort. These were the four the second tier could not write, and they arrived
|
|
;; the day function values did — so what this checks is that they are ordinary
|
|
;; prelude functions, called the ordinary way, with the function passed by
|
|
;; name or written inline.
|
|
|
|
(defn triple [x i32] i32 (* x 3))
|
|
(defn odd? [x i32] bool (= (% x 2) 1))
|
|
(defn adds [a i32 b i32] i32 (+ a b))
|
|
(defn longer-first [a i32 b i32] bool (> a b))
|
|
(defn halve [x f32] f32 (/ x 2.0))
|
|
(defn big? [x f32] bool (> x 1.0))
|
|
|
|
(defn main [] i32
|
|
;; map! writes back into the slice it was handed.
|
|
(let [xs [1 2 3 4]
|
|
s (slice xs 0 4)]
|
|
(map-i32! s triple)
|
|
(print (at s 0)) (print " ") (print (at s 3)) (println "")
|
|
|
|
;; reduce, with the accumulator first in the step. The prelude's own
|
|
;; sum-i32 is this with the + written in.
|
|
(print (reduce-i32 s 0 adds)) (println "")
|
|
;; ... and an fn literal, whose parameter types come from the parameter.
|
|
(print (reduce-i32 s 1 (fn [a b] (* a b)))) (println "")
|
|
|
|
;; filter allocates and the caller frees.
|
|
(let [v (filter-i32 s odd?)]
|
|
(print (len v)) (print " ") (print (at v 0)) (println "")
|
|
(free v))
|
|
|
|
;; A comparator sort, both directions off the same slice.
|
|
(sort-i32-by! s longer-first)
|
|
(print (at s 0)) (print " ") (print (at s 3)) (println "")
|
|
(sort-i32-by! s (fn [a b] (< a b)))
|
|
(print (at s 0)) (print " ") (print (at s 3)) (println ""))
|
|
|
|
;; The f32 half of the family, which is the same code at the other element
|
|
;; type — the copy that generics would remove.
|
|
(let [ys [(f32 4.0) (f32 1.0) (f32 8.0) (f32 2.0)]
|
|
t (slice ys 0 4)]
|
|
(map-f32! t halve)
|
|
(print (at t 0)) (print " ") (print (at t 2)) (println "")
|
|
(print (reduce-f32 t 0.0 (fn [a b] (+ a b)))) (println "")
|
|
(let [w (filter-f32 t big?)]
|
|
(print (len w)) (println "")
|
|
(free w))
|
|
(sort-f32-by! t (fn [a b] (> a b)))
|
|
(print (at t 0)) (print " ") (print (at t 3)) (println ""))
|
|
0)
|