case

(let [mystr "hello"]
  (case mystr
    "" 0
    "hello" (count mystr)))
;;=> 5

(let [mystr "no match"]
  (case mystr
        "" 0
        "hello" (count mystr)))
;; No matching clause: no match
;;  [Thrown class java.lang.IllegalArgumentException]

(let [mystr "no match"]
  (case mystr
        "" 0
        "hello" (count mystr)
        "default"))
;;=> "default"

;; You can give multiple values for the same condition by putting
;; those values in a list.
(case 'y
      (x y z) "x, y, or z"
      "default")
;;=> "x, y, or z"

(let [myseq '(1 2)]
  (case myseq
        (()) "empty seq"
        ((1 2)) "my seq"
        "default"))
;;=> "my seq"

;; "The test-constants are not evaluated.They must be compile-time
;; literals, and need not be quoted." 
(let [myvec [1 2]]
  (case myvec
        [] "empty vec"
        (vec '(1 2)) "my vec"
        "default"))
;;=> "default"

;; From: The Clojure Style Guide 
;;  https://github.com/bbatsov/clojure-style-guide#case
;;  License: Creative Commons Attribution 3.0 Unported License
;;
;; Prefer case instead of cond or condp when test expressions are compile-time constants.

;; good
(cond
  (= x 10) :ten
  (= x 20) :twenty
  (= x 30) :forty
  :else :dunno)

;; better
(condp = x
  10 :ten
  20 :twenty
  30 :forty
  :dunno)

;; best
(case x
  10 :ten
  20 :twenty
  30 :forty
  :dunno)

;; test-constants are not evaluated, so the symbols should NOT be quoted
(let [x 'a-symbol]     ; quoted
  (case x 
    a-symbol :a        ; not quoted
    b-symbol :b))      ; not quoted
;;=> :a

;; Other example on
;; "The test-constants are not evaluated. They must be compile-time
;; literals, and need not be quoted." 

(def one 1)
;;=> #'user/one
(case 1 
  one :one 
  :not-one)
;;=> :not-one

;; You can use a macro to inline test-constants you wish to define separately.

(def ops-single '("=" "!=" "<" "<=" ">" ">="))

(def ops-multi '("ONE OF" "NONE OF"))

(defmacro ops-type [op]
  `(case ~op
     ~ops-single :single
     ~ops-multi :multi))

(case :blocking
  (:blocking :compute) :block-or-compute
  :async :async)

;;=> :block-or-compute


(case :async
  (:blocking :compute) :block-or-compute
  :async :async)

;;=> :async

;; I timed rmprescott's example:

(let [x 30] 
  ;; "good"
  (time (cond
          (= x 10) :ten
          (= x 20) :twenty
          (= x 30) :thirty
          :else :dunno))     ;;=> "Elapsed time: 0.0666 msecs"

  ;; "better"
  (time (condp = x
          10 :ten
          20 :twenty
          30 :thirty
          :dunno))           ;;=> "Elapsed time: 0.4197 msecs"

  ;; best in performance if else statement is executed (not shown)
  ;; best in readability
  (time (case x
          10 :ten
          20 :twenty
          30 :thirty
          :dunno))           ;;=> "Elapsed time: 0.0032 msecs"
 
  ;; best in performance if known branches are executed
  ;; worst in readability
  (time (if (= x 10)
          :ten
          (if (= x 20)
            :twenty
            (if (= x 30)
              :thirty
              :dunno))))))   ;;=> "Elapsed time: 0.0021 msecs" 

;;=> :thirty

;; demonstrates inclusion on the test
;; ... could be one of "what" or "why"

(case "what"
    ("what" "why") :question
    :something-else)

;;=> :question