;;;; [const T]: a slice that can only be read. bytes-view answers one, a [T]
;;;; converts to one wherever one is wanted, and slicing one keeps it
;;;; read-only. Nothing about it exists at run time, so this prints the same
;;;; on every backend and at every level.

(defn total [s [const i32]] i64
  (let [t (i64 0)]
    (dotimes [i (length s)]
      (set t (+ t (at s i))))
    t))

;; A generic over a read-only slice takes a writable one too.
(defn first-of [s [const $t]] $t (at s 0))

(defn widths [parts [const [const u8]]] i32
  (let [n 0]
    (dotimes [i (length parts)]
      (set n (+ n (length (at parts i)))))
    n))

(defn main [] i32
  (let [xs [3 1 2]
        w (slice xs)
        r (bytes-view "hello, world")
        head (slice r 0 5)
        tail (slice r 7)
        names (vec-new [const u8])]
    (sort w)
    (println (total w) (total (slice w 1)))
    (println (first-of w) (first-of (bytes-view "z")))
    (println (string head) (string tail) (length head))
    (println (bytes=? head (bytes-view "hello")) (starts-with? r head))
    (push names head)
    (push names tail)
    (println (widths (slice names)))
    ;; A writable [[u8]] meets [const [const u8]] too: the outer view is
    ;; read-only, so nothing can put a read-only slice into it.
    (let [a (bytes "ab")
          b (bytes "cde")
          both [a b]]
      (println (widths (slice both)))
      (set (at a 0) \A)
      (println (string a)))
    (let [f (split (bytes-view "b,a,c") \,)]
      (sort-bytes (slice f))
      (println (string (slice (join (slice f) (bytes-view "-"))))))
    (println (at r 0))
    (free names))
  0)