clojure.core/loop

View this page on ClojureDocs

Type: macro Added: Clojure 1.0 Examples: 14 Runnable: 10

([bindings & body])

Evaluates the exprs in a lexical context in which the symbols in the binding-forms are bound to their respective init-exprs or parts therein. Acts as a recur target.

Examples

by nipra on 2010-07-13 . May have evaluation errors. ▶

;; looping is recursive in Clojure, the loop construct is a hack so that ;; something like tail-recursive-optimization works in Clojure. (defn my-re-seq "Something like re-seq" [re string] (let [matcher (re-matcher re string)] (loop [match (re-find matcher) ;loop starts with 2 set arguments result []] (if-not match result (recur (re-find matcher) ;loop with 2 new arguments (conj result match)))))) #'user/my-re-seq (my-re-seq #"\d" "0123456789") ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9"]

by devijvers on 2010-07-19 . May have evaluation errors. ▶

;; Read decoded MP3 data in loop (requires mp3plugin.jar on class path) ;; http://java.sun.com/javase/technologies/desktop/media/jmf/mp3/download.html (import '(javax.sound.sampled AudioSystem AudioFormat$Encoding)) (let [mp3-file (java.io.File. "tryout.mp3") audio-in (AudioSystem/getAudioInputStream mp3-file) audio-decoded-in (AudioSystem/getAudioInputStream AudioFormat$Encoding/PCM_SIGNED audio-in) buffer (make-array Byte/TYPE 1024)] (loop [] (let [size (.read audio-decoded-in buffer)] (when (> size 0) ;do something with PCM data (recur)))))

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

(loop [x 10] (when (> x 1) (println x) (recur (- x 2)))) ;;=> 10 8 6 4 2

by dansalmo on 2012-08-20 . May have evaluation errors. ▶

(defn find-needle [needle haystack] ;loop binds initial values once, ;then binds values from each recursion call (loop [needle needle maybe-here haystack not-here '()] (let [needle? (first maybe-here)] ;test for return or recur (if (or (= (str needle?) (str needle)) (empty? maybe-here)) ;return results [needle? maybe-here not-here] ;recur calls loop with new values (recur needle (rest maybe-here) (concat not-here (list (first maybe-here)))))))) (find-needle "|" "hay|stack") [\| (\| \s \t \a \c \k) (\h \a \y)]

by bartq on 2013-03-15 ▶

; makes a simple template function that can be used in mustache way: http://mustache.github.com/ (defn template [tpl env] (loop [tpl tpl env env] (cond (empty? env) tpl :else (let [[key value] (first env)] (recur (try (clojure.string/replace tpl (re-pattern (str "\\{\\{" (name key) "\\}\\}")) value) (catch Exception e tpl)) (rest env))))))

by Miloas on 2015-07-13 ▶

(loop [iter 1 acc 0] (if (> iter 10) (println acc) (recur (inc iter) (+ acc iter)))) ;; => 55 ;; sum from 1 to 10

by clojurianix on 2016-05-21 ▶

;; loop is the recursion point for recur. The symbols in loop's ;; binding-forms are bound to their respective init-exprs and ;; rebound to the values of recur's exprs before the next execution ;; of loop's body. ;; calculate the factorial of n (loop [n (bigint 5), accumulator 1] (if (zero? n) accumulator ; we're done (recur (dec n) (* accumulator n)))) ;;=> 120N ;; square each number in the vector (loop [xs (seq [1 2 3 4 5]) result []] (if xs (let [x (first xs)] (recur (next xs) (conj result (* x x)))) result)) ;; => [1 4 9 16 25]

by RobinNagpal on 2017-07-29 ▶

;; 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 RobinNagpal on 2017-07-29 ▶

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

by phronmophobic on 2017-11-28 ▶

;; Iterating over a collection using loop ;; 1. First call (seq xs) on the given argument and then check for nil ;; 2. Then call next/first and use these. (loop [xs (seq [1 2 3 4 5]) result []] (if xs (let [x (first xs)] (recur (next xs) (conj result (* x x)))) result)) ;; the same loop can be written using destructing, ;; but the compiler will generate two consecutive ;; seq calls and is slightly less efficient. (loop [[x & r :as xs] (seq []) result []] (if xs (recur r (conj result (* x x))) result))

by ibercode on 2017-12-14 ▶

;;basic loop example #1 (loop [x 0 result []] (if (< x 10) (recur (inc x) (conj result x)) result)) ;;[0 1 2 3 4 5 6 7 8 9] ;;basic loop example #2 (def citrus-list ["lemon" "orange" "grapefruit"]) (defn display-citrus [citruses] (loop [[citrus & citruses] citruses] (println citrus) (if citrus (recur citruses)))) (display-citrus citrus-list)

by ibercode on 2018-01-14 ▶

;;loop general strategy ;;given a collection of numbers [1 2 3 4 5], ;;return a new collection [10 20 30 40 50] (def my-vector [1 2 3 4 5]) (defn my-new-vector [coll] (loop [remain coll final-vec []] (if (empty? remain) final-vec (let [[unit & remaining] remain] (recur remaining (into final-vec [(* 10 unit)])))))) (my-new-vector my-vector) ;;[10 20 30 40 50] ;;to sum all the elements from the newly created collection: (reduce + (my-new-vector my-vector)) ;;150

by jiro4989 on 2018-11-15 ▶

;; loop -> recur sample with fizzbuzz code. (defn fizzbuzz [n] (loop [f [] i 1] (if (< n i) f (recur (conj f (cond (zero? (mod i 15)) "fizzbuzz" (zero? (mod i 3)) "fizz" (zero? (mod i 5)) "buzz" :else i)) (inc i))))) (println (fizzbuzz 100)) ;; output is ;; [1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 buzz fizz 22 23 fizz buzz 26 fizz 28 29 fizzbuzz 31 32 fizz 34 buzz fizz 37 38 fizz buzz 41 fizz 43 44 fizzbuzz 46 47 fizz 49 buzz fizz 52 53 fizz buzz 56 fizz 58 59 fizzbuzz 61 62 fizz 64 buzz fizz 67 68 fizz buzz 71 fizz 73 74 fizzbuzz 76 77 fizz 79 buzz fizz 82 83 fizz buzz 86 fizz 88 89 fizzbuzz 91 92 fizz 94 buzz fizz 97 98 fizz buzz]

by jimka2001 on 2024-05-28 . May have evaluation errors. ▶

;; loop accepts pre and post conditions (loop [left -1.0 right 1.0] {:pre [(< left right)]} ...)

Note by Jacolyte

"Acts as a recur target."

What's a recur target? A recurring target? A recursive target? I'm not a big fan of abbreviations or ambiguous terms.

Wouldn't it be awesome if a script could annotate all occurrences of glossary terms? Or automatically wrap glossary terms in anchor tags linking to their definition?

Note by devijvers

The problem loop is trying to solve is that recursively calling the same function on the JVM is expensive and doesn't scale. It might work if your data structure is a thousand levels deep but it will fail badly with a depth of millions of levels.

What is not possible on the JVM is what is called "tail-call optimization". loop is like a while loop in java, except that if you don't call recur (with the correct number of arguments) the loop will exit. In while-loop terms, recur avoids that a break statement is executed.

int counter = 0;
while (true) {
   if (counter < 10) {
      // recur
      counter = inc(counter);
   } else {
      break;
   }
}

In that sense loop is a recur target as in "target for recursion".

Note by Jacolyte

I wish the word recur in this document linked to the recur function. That'd be... awesome.

Note by zk

It really should (and will) show up in the 'vars in' section.

The problem is that recur is a special form, and is not parsed out correctly like other vars. This will be fixed in the future.

Note by Dimagog

Majority of loops that novices write can be expressed more elegantly using 3 fundamental functions map, filter and reduce. Or using list comprehension for.

Note by pmonks

To be clear, there's no technical reason the JVM can't support tail recursion (despite some complications to do with call stacks and security) - it just doesn't happen to support them currently.

People have been requesting this enhancement for at least a decade - here's one proposal, for example.

See also

• clojure.core/recur (9)
• clojure.core/trampoline (3)
• clojure.core/when (3)
• clojure.core/while (1)
• clojure.core/for (14)
• clojure.core/doseq (9)
• clojure.core/reduce (22)
• clojure.core/dotimes (1)

---

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