;;;; A typed char (decision 127): a char literal is a char unless typed code
;;;; wants a number, and a char crossing into dyn stays a char. It compares,
;;;; orders and hashes; (i32 c) and (char n) convert. With "dyn-int" a dyn
;;;; int at a char parameter traps, and with "surrogate" (char n) does.

(defn show [x] () (println x))
(defn take-char [c char] char c)
(defn next-char [c char] char (char (+ (i32 c) 1)))
(defn a-dyn [x] dyn x)

(defn main [args [str]] i32
  ;; A direct literal and a let-bound one print alike through dyn.
  (show \a)
  (let [c \a] (show c))
  ;; Printed as its literal, as a dyn char is, alone and inside a value.
  (let [e \é]
    (println e [e \z \space])
    (println (i32 e) (u32 e)))
  ;; Equality and ordering by code point.
  (println (< \a \b) (= \a \a) (!= \a \b) (>= \é \z) (min \q \c) (max \q \c))
  ;; Conversions both ways.
  (println (char 65) (char 0x1F600) (i32 \A) (u8 \A) (next-char \y))
  (let [n 66] (println (char n)))
  ;; A map keyed by char.
  (let [m (map-new char i32)]
    (put m \x 1)
    (put m \é 2)
    (println (get m \x) (get m \é) (has-key? m \y)))
  ;; A match over a char.
  (let [k \b]
    (println (match k \a 1 \b 2 _ 0)))
  ;; Byte code is unchanged: a literal beside a byte is the byte.
  (let [b (u8 97)
        v (vec-new u8)
        s (string-new)]
    (println (= b \a) (= \a b))
    (push v \z)
    (println (at v 0))
    ;; And a char appends to a String as its UTF-8.
    (append s \é)
    (append s (char 0x65E5))
    (println s))
  ;; A dyn char into a typed char, and typed chars viewed from dyn.
  (println (take-char (a-dyn \q)))
  (let [cs [\x \y]]
    (show cs)
    (show (at (a-dyn cs) 1)))
  (when (> (length args) 1)
    (if (= (at args 1) "dyn-int")
      (println (take-char (a-dyn 97)))
      (let [n (+ 0xD800 (length args))]
        (println (char n)))))
  0)