;; 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)