clojure.core/when-let

View this page on ClojureDocs

Type: macro Added: Clojure 1.0 Examples: 8 Runnable: 6

([bindings & body])

bindings => binding-form test

When test is true, evaluates body with binding-form bound to the value of test

Examples

by kotarak on 2010-08-11 ▶

;; Very useful when working with sequences. Capturing the return value ;; of `seq` brings a performance gain in subsequent `first`/`rest`/`next` ;; calls. Also the block is guarded by `nil` punning. (defn drop-one [coll] (when-let [s (seq coll)] (rest s))) (drop-one [1 2 3]) (2 3) (drop-one []) nil

by jafingerhut on 2012-04-13 ▶

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

by mattvvhat on 2015-04-09 ▶

;; Works well with collections (def x {:whatever 1}) (when-let [value (:whatever x)] (println "x+1 = " (inc value))) ;; Prints: "x+1 = 2"

by ertugrulcetin on 2016-07-26 ▶

;; when-let multiple bindings version (defmacro when-let* ([bindings & body] (if (seq bindings) `(when-let [~(first bindings) ~(second bindings)] (when-let* ~(drop 2 bindings) ~@body)) `(do ~@body)))) (when-let* [a 1 b 2 c (+ a b)] (println "yeah!") c) ;;=>yeah! ;;=>3 (when-let* [a 1 b nil c 3] (println "damn! b is nil") a) ;;=>nil

by bfabry on 2017-09-15 . May have evaluation errors. ▶

;; test is evaluated before values are bound to binding, so destructuring works (when-let [[a] nil] [a]) => nil (when-let [[a] [:a]] [a]) => [:a] (when-let [{:keys [a]} nil] [a]) => nil ;; but empty collections and missing keys present a gotcha (when-let [[a] []] [a]) => [nil] (when-let [{:keys [a]} {}] [a]) => [nil] (when-let [{:keys [a]} {:b 2}] [a]) => [nil]

by arlicle on 2018-09-04 ▶

;; when-let multiple bindings version ;; all bindings are evaluated before checking for falsyness (defmacro when-let* [bindings & body] `(let ~bindings (if (and ~@(take-nth 2 bindings)) (do ~@body) ))) (when-let* [a 1 b 2 c (+ a b)] (println "yeah!") c) ;;yeah! ;;=> 3 (when-let* [a 1 b nil c 3] (println "damn! b is nil") a) ;;=> nil

by Jjunior130 on 2018-09-09 . May have evaluation errors. ▶

(require '[reagent.core :as r]) (def float-parsable? (comp not js/isNaN js/parseFloat)) (def find-parsable-or-nil (comp first (partial re-find #"(\-?\d+\.)?\d+([eE][-+]?\d+)?"))) (defn number-input "HTML input element for number only input" [value] [:input {:value @value :type "text" :on-change (comp #(when-let [new-value %] (reset! value new-value)) (fn [value] (cond (empty? value) "" (float-parsable? value) value :otherwise (find-parsable-or-nil value))) (fn [target] (.-value target)) (fn [event] (.-target event)))}]) (def value (r/atom "")) (defn demo [] [:div ; Displays NaN when value is "", displays a number otherwise. (-> @value js/parseFloat str) [:br] [number-input value]])

by arcanjoaq on 2024-06-20 ▶

;; when-let with boolean values and nil (when-let [f true] (println "Hello world!!!")) ;; prints Hello world!!! ;;=>Hello world!!! ;;=>nil (when-let [f false] (println "Hi!!!")) ;; prints nothing ;;=>nil (when-let [f nil] (println "Wassup!!!")) ;; prints nothing ;;=>nil

Note by gstamp

The difference between when-let and if-let is that when-let doesn't have an else clause and and also accepts multiple forms so you don't need to use a (do...).

Note by n2o

The word "bindings" seems not to be correct here. In fact when-let only accepts one binding and not multiple ones. So "bindings" might be confusing, at least it was for me.

Note by Dave Y.

Agreed. It ought to be "binding" for clarity.

Note by HomoEfficio

(when-let [name test]
  (do-something-with-name))

In the example above, test does not have to be a predicate. test can be any value which is like (seq coll) or 3, [1 2], or so.

If test is neither false nor nil, test is bound to name.

See also

• clojure.core/if-let (7)
• clojure.core/when (3)
• clojure.core/when-not (5)
• clojure.core/if (2)
• clojure.core/when-first (2)
• clojure.core/when-some (3)
• clojure.core/let (7)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.