case.clje

(ns examples.case)

(def assert-with-tags
  (fn* [result & tags]
       (if result
         nil
         (erlang/error #erl[:failed-assertion tags]))))

(let* [x :b
       y (case* x
                :a 1
                :b 2
                :c 3)
       z (case* y
                x :one
                #erl [:default :value])]
  (assert-with-tags (erlang/=:= x :b) :x)
  (assert-with-tags (erlang/=:= y 2) :y)
  (assert-with-tags (erlang/=:= z #erl[:default :value]) :z))

(def case-match-ignore
  (fn* [x]
       (case* x
              #erl[_ y _] y)))

;; First and third don't have to be equal
(let* [2 (case-match-ignore #erl[1 2 3])])

(def case-match
  (fn* [x]
       (case* x
              #erl[a y a] y)))

;; First and third have to be equal
(let* [2 (case-match #erl[1 2 1])])

;; [#684] Pattern matching ignores existing bound symbol

(def equal?
  (fn* [x y]
       (case* x
              y :equal
              _ :not_equal)))

(assert-with-tags (erlang/=:= (equal? 1 1) :equal))
(assert-with-tags (erlang/=:= (equal? 1 2) :not_equal))

(def multiple-locals-not-ordered
  (fn* [t & a]
       (let* [r 5]
         (loop* [n 10]
           (case* n
                  r #erl[:five n]
                  _ (recur (erlang/- n 1))
                  0 :zero)))))

(assert-with-tags (erlang/=:= (multiple-locals-not-ordered 1 1)
                              #erl[:five 5]))

(def two-bindings-same-name-in-let
  (fn* []
       (let* [x 1
              x 2
              y 1]
         (case* y
                x :x-is-one
                :x-is-two))))

(assert-with-tags
 (erlang/=:= (two-bindings-same-name-in-let)
             :x-is-two))

(def three-bindings-same-name-in-let
  (fn* []
       (let* [x 1
              x 2
              x 3
              y 1]
         (case* y
                x :x-is-one
                :x-is-three))))

(assert-with-tags
 (erlang/=:= (three-bindings-same-name-in-let)
             :x-is-three))