;;;; get over an array, a slice, a string and a Vec is at that answers None
;;;; for an index out of range, negative included, one index per dimension.
;;;; Over a dyn it answers nil, and more keys walk a level each.

(defn show [o (Option i32)] ()
  (match o (Some v) (println v) None (println "none")))

(defn three [] (Vec i32)
  (let [v (vec-new i32)] (push v 10) (push v 20) (push v 30) v))

(defn dvec [] dyn [10 [20 21] 30])
(defn dmap [] dyn {:a 1 :b [5 6]})
(defn dtext [] dyn "hey")

(defn main [] ()
  (let [a [1 2 3]
        grid [[1 2 3] [4 5 6]]
        s (slice a)
        v (three)
        n (length a)
        vv (vec-new (Vec i32) context/temp)]
    (push vv v)
    ;; -1, 0, len-1 and len on an array.
    (show (get a -1))
    (show (get a 0))
    (show (get a (- n 1)))
    (show (get a n))
    ;; Two dimensions, each tested.
    (let [r 0 c 1]
      (show (get grid (+ r 1) (- c 1)))
      (show (get grid (- r 1) c))
      (show (get grid r (+ c 2))))
    (show (get grid 1 2))
    (show (get grid 2 0))
    ;; A slice.
    (show (get s 2))
    (show (get s 3))
    ;; A Vec, and one a call answered.
    (show (get v -1))
    (show (get v 0))
    (show (get v 2))
    (show (get v 3))
    (show (get (three) 1))
    ;; A Vec of Vecs: the inner length is tested only once the outer index is.
    (show (get vv 0 2))
    (show (get vv 0 3))
    (show (get vv 1 0))
    ;; A string's byte.
    (match (get "hey" 1) (Some b) (println b) None (println "none"))
    (match (get "hey" 3) (Some b) (println b) None (println "none")))
  ;; Dyn.
  (let [d (dvec) m (dmap)]
    (println (get d -1))
    (println (get d 0))
    (println (get d 2))
    (println (get d 3))
    (println (get d 1 1))
    (println (get d 1 2))
    (println (get d 5 0))
    (println (get m :a))
    (println (get m :z))
    (println (get m :b 1))
    (println (get m :z 1))
    (println (.a m))
    ;; Dyn text: get counts it as at does.
    (println (get (dtext) 1))
    (println (get (dtext) 3))))