(defstruct Cell [x i32 y i32])
(defstruct Named [tag string n i32])

(defn main [] i32
  ;; An integer key, past several grows: 2000 entries in a map that starts at 8.
  (let [m (map-new i32 i64)]
    (dotimes [i 2000]
      (put m i (* (i64 i) 3)))
    (print (len m)) (println "")
    (let [bad 0]
      (dotimes [i 2000]
        (match (get m i)
          (Some v) (if (not (= v (* (i64 i) 3))) (set bad (+ bad 1)))
          None (set bad (+ bad 1))))
      (print bad) (println ""))
    (free m))

  ;; A struct key: the compiler emits a hash and an equality pair for Cell and
  ;; walks it field by field, so padding is never read.
  (let [g (map-new Cell i32)]
    (dotimes [i 40]
      (dotimes [j 40]
        (put g (Cell {.x i .y j}) (+ (* i 100) j))))
    (print (len g)) (println "")
    (match (get g (Cell {.x 7 .y 9})) (Some v) (do (print v) (println "")) None (println "missing"))
    (print (has-key? g (Cell {.x 39 .y 39}))) (println "")
    (print (has-key? g (Cell {.x 40 .y 0}))) (println "")
    (free g))

  ;; A struct key holding a string: the string field hashes its bytes, so two
  ;; equal strings at different addresses find the same entry.
  (let [n (map-new Named i32)]
    (put n (Named {.tag "alpha" .n 1}) 10)
    (put n (Named {.tag "alpha" .n 2}) 20)
    (put n (Named {.tag "beta"  .n 1}) 30)
    (print (len n)) (println "")
    (match (get n (Named {.tag "alpha" .n 2})) (Some v) (do (print v) (println "")) None (println "missing"))
    (print (has-key? n (Named {.tag "alpha" .n 3}))) (println "")
    (free n))

  ;; clone is a deep, independent copy.
  (let [a (map-new i32 i32)]
    (put a 1 100)
    (put a 2 200)
    (let [b (clone a)]
      (put b 1 999)
      (match (get a 1) (Some v) (do (print v) (println "")) None (println "missing"))
      (match (get b 1) (Some v) (do (print v) (println "")) None (println "missing"))
      (print (len b)) (println "")
      (free b))
    (free a))
  0)