(defstruct P [x i32 y i32])
(defn app [g (Fn [i32] i32) v i32] i32 (g v))

(defn shadow-chain [] ()
  (let [x 1]
    (let [x (+ x 10)]
      (println x))
    (println x)
    (let [x (+ x 100)]
      (println x)
      (let [x (* x 2)] (println x))
      (println x))
    (println x)))

(defn closes [] i32
  (let [x 1]
    (let [x 5]
      (println x))
    (let [f 0]
      (app (fn [y] (+ x y)) (+ f 2)))))

(defn loopy [] ()
  (let [i 0]
    (while (< i 5)
      (let [i (* i 100)]
        (println i))
      (set i (+ i 1))
      (when (= i 3) (continue))
      (println i))))

(defn loopr [] i32
  (let [n 0 acc 0]
    (while true
      (let [n (* n 2)]
        (println n))
      (if (< n 4)
        (do (set acc (+ acc n)) (set n (+ n 1)))
        (break)))
    acc))

(defn ret [a i32] i32
  (let [a (+ a 1)]
    (println a))
  (when (> a 3)
    (let [a 0] (println a))
    (return a))
  (let [a (- a 1)] (println a))
  a)

(defn deferring [] ()
  (let [x 1]
    (let [x 2]
      (defer (println x)))
    (defer (println x))
    (println "body")))

(defn destr [] ()
  (let [p (P {.x 3 .y 4}) x 100]
    (let [{.x .y} p]
      (println (+ x y)))
    (println x)
    (let [{:keys [x]} p]
      (println x))
    (println x)
    (let [[a b] [x 7]]
      (println a))
    (println x)))

(defn dos [c bool] i32
  (let [v 0]
    (if c
      (do (let [v 5] (println v)) (println v))
      (do (let [v 6] (println v)) (println v)))
    (unless c (let [v 9] (println v)) (println v))
    (when c (let [v 8] (println v)) (println v))
    v))

(defn main [] i32
  (shadow-chain)
  (println (closes))
  (loopy)
  (println (loopr))
  (println (ret 5))
  (println (ret 1))
  (deferring)
  (destr)
  (println (dos true))
  (println (dos false))
  0)