clojure.core/recur

View this page on ClojureDocs

Type: var Added: Clojure unknown Examples: 9 Runnable: 9

()

Evaluates the exprs in order, then, in parallel, rebinds the bindings of the recursion point to the values of the exprs. See http://clojure.org/special_forms for more information.

Examples

by ique on 2010-11-20 ▶

(def factorial (fn [n] (loop [cnt n acc 1] (if (zero? cnt) acc (recur (dec cnt) (* acc cnt)) ; in loop cnt will take the value (dec cnt) ; and acc will take the value (* acc cnt) ))))

by ique on 2010-11-20 ▶

; A loop that sums the numbers 10 + 9 + 8 + ... ; Set initial values count (cnt) from 10 and down (loop [sum 0 cnt 10] ; If count reaches 0 then exit the loop and return sum (if (= cnt 0) sum ; Otherwise add count to sum, decrease count and ; use recur to feed the new values back into the loop (recur (+ cnt sum) (dec cnt))))

by john.r.woodward on 2012-07-19 ▶

(loop [i 0] (when (< i 5) (println i) (recur (inc i)); loop i will take this value ))

by azkesz on 2012-08-26 ▶

(defn compute-across [func elements value] (if (empty? elements) value (recur func (rest elements) (func value (first elements))))) (defn total-of [numbers] (compute-across + numbers 0)) (defn larger-of [x y] (if (> x y) x y)) (defn greatest-of [numbers] (compute-across larger-of numbers (first numbers)))

by jdwaterson on 2015-09-20 ▶

; Note that recur can be surprising when using variadic functions. (defn foo [& args] (let [[x & more] args] (prn x) (if more (recur more) nil))) (defn bar [& args] (let [[x & more] args] (prn x) (if more (bar more) nil))) ; The key thing to note here is that foo and bar are identical, except ; that foo uses recur and bar uses "normal" recursion. And yet... (foo :a :b :c) :a :b :c nil (bar :a :b :c) :a (:b :c) nil ; The difference arises because recur does not gather variadic/rest args ; into a seq.

by teymuri on 2015-09-25 ▶

;;This will generate the first 1000 Fibonacci numbers ;;(using incrementing and decrementing): (loop [res [0 1]] (if (>= (count res) 1000) res (recur (conj res (+' (inc (last res)) (dec (last (butlast res))))))))

by clojurianix on 2016-05-21 ▶

;; The recursion point can be a 'loop' or a 'fn' method. (loop [n (bigint 5), accumulator 1] (if (zero? n) accumulator ; we're done (recur (dec n) (* accumulator n)))) ;;=> 120N ((fn factorial ([n] (factorial n 1)) ([n accumulator] (if (zero? n) accumulator ; we're done (recur (dec n) (* accumulator n))))) (bigint 5)) ;;=> 120N

by caumond on 2020-12-23 ▶

;; Trailing position could be multiple (loop [x 1] (println "x= " x) (cond (> x 10) (println "ending at " x ) (even? x) (recur (* 2 x)) :else (recur (+ x 1))))

by conao3 on 2024-10-02 ▶

;; see `foo` and `bar` above ;; this `baz` uses normal recursion, this blows stacks but `foo` doesn't (defn baz [& args] (let [[x & more] args] (prn x) (if more (apply baz more) nil))) (baz :a :b :c) ;; :a ;; :b ;; :c ;;=> nil

See also

• clojure.core/loop (10)
• clojure.core/trampoline (3)

---

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