clojure.core/cond

View this page on ClojureDocs

Type: macro Added: Clojure 1.0 Examples: 9 Runnable: 5

([& clauses])

Takes a set of test/expr pairs. It evaluates each test one at a time. If a test returns logical true, cond evaluates and returns the value of the corresponding expr and doesn't evaluate any of the other tests or exprs. (cond) returns nil.

Examples

by dpritchett on 2010-07-14 ▶

(defn pos-neg-or-zero "Determines whether or not n is positive, negative, or zero" [n] (cond (< n 0) "negative" (> n 0) "positive" :else "zero")) (pos-neg-or-zero 5) "positive" (pos-neg-or-zero -1) "negative" (pos-neg-or-zero 0) "zero"

by bhenry on 2010-07-14 ▶

(let [grade 85] (cond (>= grade 90) "A" (>= grade 80) "B" (>= grade 70) "C" (>= grade 60) "D" :else "F")) "B"

by jafingerhut on 2012-04-13 ▶

;; See examples for "if" explaining Clojure's idea of logical true ;; and logical false.

by Omer on 2012-05-29 . May have evaluation errors. ▶

;; Generates a random number compares it to user input (let [rnd (rand-int 10) guess (Integer/parseInt (read-line))] (cond (= rnd guess) (println "You got my guess right!") :else (println "Sorry... guess again!")))

by mhmdsalem1993 on 2016-04-06 . May have evaluation errors. ▶

;; Simple Condition Example (defn test-x [x] (cond (< x 10) "less than" (> x 20) "greater than" ) ) ============test============ (test-x 9) => "less than"

by RobinNagpal on 2017-08-13 . May have evaluation errors. ▶

(defn print-cond [xx] (cond (< xx 6) "less than 6" (< xx 8) "less than 8" :else "Greater than 8")) => #'aurora.system/print-cond (print-cond 5) => "less than 6" (print-cond 7) => "less than 8" (print-cond 8) => "Greater than 8" (print-cond 10) => "Greater than 8"

by chrismurrph on 2017-08-31 ▶

;; If a condition is not matched `nil` will be returned (cond false "sumfin") ;;=> nil

by berczeck on 2020-08-24 ▶

;; Instead of use the :else keyword as the default path you can use ;; whatever that gives meaning to the code (cond :whatever "You can use any default keyword") ;; You can use any default keyword

by digash on 2021-02-19 . May have evaluation errors. ▶

;; cond is a macro the easiest way to understand how it works is to macroexpand it (clojure.walk/macroexpand-all '(let [n 3] (cond (odd? n) "odd" (even? n) "even" (< n 0) "negitive" (< 0 n) "positive" :else "zero"))) (let [n 3] (if (odd? n) "odd" (if (even? n) "even" (if (< n 0) "negitive" (if (< 0 n) "positive" (if :else "zero" nil))))))

Note by blais

We should add a comment in the docstring for the final usage of :else.

Note by kimtg

:else is not special. Any keyword will do.

Note by seltzer1717

Actually any non-nil or true will work. I prefer to use :default. :else implies truthiness in evaluation rather what it really is which is a 'default' value.

Note by yubrshen

It seems the documentation is not accurate. From my experiment, it seems the function decscription should be like the following:

Takes a set of test/expr pairs. It evaluates each test one at a time.
If a test returns logical true, cond evaluates the corresponding expr and continue to evaluate the next test/expr, until a test fails or no more pair of test(:else)/expr to evaluate, and returns the last evaluation value of the expr that its corresponding test evaluated to truthy. If there is no test evaluated to truthy, return the evaluation of :else clause. If there is no :else clause return nil.

The above description can be supported by the following example:

(defn pos-neg-or-zero
  "Determines whether or not n is positive, negative, or zero"
  [n]
  (cond
    (odd? n) "odd"
    (even? n) "even"
    (< n 0) "negitive"
    (< 0 n) "positive"
    :else "zero"))

(odd? 3)                                ; => true
(pos-neg-or-zero 3)                     ;=> "positive"
(even? 0)                               ; => true
(pos-neg-or-zero 0)                     ;=> "zero"
(even? 4)                               ; => true
(pos-neg-or-zero 4)                     ;=> "positive"



### Note by maruks

yubrshen,   

(pos-neg-or-zero 3) => "odd"

### Note by dan-mcdonald

`:else` is just a convention. It works because

=> (boolean :else)
true


In fact anything except for `false` and `nil` will evaluate to `true` (see [boolean](https://clojuredocs.org/clojure.core/boolean)).


## See also



  clojure.core/condp (10)


  clojure.core/case (5)


  clojure.core/if (2)


  clojure.core/cond-> (4)





---

Content from [the matching ClojureDocs page](https://clojuredocs.org/clojure.core/cond), with authors
credited on each contribution.