Clojure loop collection

Question

I want to know if this is the right way to loop through an collection:

(def citrus-list ["lemon" "orange" "grapefruit"])

(defn display-citrus [citruses]
  (loop [[citrus & citruses] citruses]
    (println citrus)
    (if citrus (recur citruses))
    ))

(display-citrus citrus-list)

I have three questions:

the final print displays nil, is it ok or how can avoid it?
I understand what & is doing in this example but I don´t see it in other cases, maybe you could provide a few examples
Any other example to get the same result?

Thanks, R.

It depends on what you want to do with each item in the collection. If you just want to print as you are doing here then doseq is a good choice. However map, reduce, loop/recur and iterate can all go through all the items in a collection. — Chris Murphy
– Chris Murphy, Commented Dec 14, 2017 at 12:23

leetwinski · Accepted Answer · 2017-12-14 12:27:57Z

2

First of all your implementation is wrong. It would fail if your list contains nil:

user> (display-citrus [nil "asd" "fgh"])
;;=> nil
nil

And print unneeded nil if the list is empty:

user> (display-citrus [])
;;=> nil
nil

you can fix it this way:

(defn display-citrus [citruses]
  (when (seq citruses)
    (loop [[citrus & citruses] citruses]
      (println citrus)
      (if (seq citruses) (recur citruses)))))

1) it is totally ok: for non-empty collection the last call inside function is println, which returns nil, and for empty collection you don't call anything, meaning nil would be returned (clojure function always returns a value). To avoid nil in your case you should explicitly return some value (like this for example):

(defn display-citrus [citruses]
  (when (seq citruses)
    (loop [[citrus & citruses] citruses]
      (println citrus)
      (if (seq citruses) (recur citruses))))
  citruses)

user> (display-citrus citrus-list)
;;=> lemon
;;=> orange
;;=> grapefruit
["lemon" "orange" "grapefruit"]

2) some articles about destructuring should help you

3) yes, there are some ways to do this. The simplest would be:

(run! println citrus-list)

answered Dec 14, 2017 at 12:27

leetwinski

17.9k2 gold badges21 silver badges44 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

leetwinski Over a year ago

Obviously. I just wanted to keep it as close to the op's variant as possible, so he could easily see the difference

Ivan Grishaev · Accepted Answer · 2017-12-14 13:12:59Z

2

Answering your last question, you should avoid using loop in Clojure. This form is rather for experienced users that really know what they do. In your case, you may use such more user-friendly forms as doseq. For example:

(doseq [item collection]
  (println item))

You may also use map but keep in mind that it returns a new list (of nils if your case) that not sometimes desirable. Say, you are interested only in printing but not in the result.

In addition, map is lazy and won't be evaluated until it has been printed or evaluated with doall.

answered Dec 14, 2017 at 13:12

Ivan Grishaev

1,68911 silver badges16 bronze badges

Comments

user5239066 · Accepted Answer · 2017-12-14 12:27:20Z

For most purpose, you can use either map, for or loop.

=> (map count citrus-list)
(5 6 10)

=> (for [c citrus-list] (count c))
(5 6 10)

=> (loop [[c & citrus] citrus-list
           counts []]
     (if-not c counts
       (recur citrus (conj counts (count c)))))
[5 6 10]

I tend to use map as much of possible. The syntax is more concise, and it clearly separates the control flow (sequential loop) from the transformation logic (count the values).

For instance, you can run the same operation (count) in parallel by simply replacing map by pmap

=> (pmap count citrus-list)
[5 6 10]

In Clojure, most operations on collection are lazy. They will not take effect as long as your program doesn't need the new values. To apply the effect immediately, you can enclose your loop operation inside doall

=> (doall (map count citrus-list))
(5 6 10)

You can also use doseq if you don't care about return values. For instance, you can use doseq with println since the function will always return nil

=> (doseq [c citrus-list] (println c))
lemon
orange
grapefruit

Collectives™ on Stack Overflow

Clojure loop collection

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related