50 lines
1.6 KiB
Plaintext
50 lines
1.6 KiB
Plaintext
;;;; [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)
|