Idiomatic and lazy eventually truthy in a list in Clojure

Question

I'd like to have a function/macro for checking a list to have truthy value eventually, and I hope the evaluation would be lazy. Here is my illustrative implementation without lazy evaluation:

(defn eventual [cols]
  (or (first cols) (if-let [rs (rest cols)]
                     (eventual rs))
                     false))

Here is a trivial example to illustrate:

(if (eventual [false (+ 1 2) (* 10000 10000)])
  true
  false)

I feel that there must be an implication with lazy evaluation. Maybe I'm just blinded at the moment. Please help to help. Thanks

score 2 · Accepted Answer · answered May 20 '16 at 08:40

You can check if a sequence contains at least one truthy element with some function:

(some identity col)

If you pass it a lazy sequence as col it will evaluate its contents up to the first truthy element and won't realise the rest:

(let [col (take
            10
            (iterate
              #(do (println "Generating new value from " %) (inc %))
              0))]
  (some #(> % 5) col))

produces:

Generating new value from  0
Generating new value from  1
Generating new value from  2
Generating new value from  3
Generating new value from  4
Generating new value from  5
true

As you can see, values 6..9 are not produces at all.

You also should double check that the col you pass to some is really lazy and not already realised, because it might confuse you.

Thanks for helping to getting the real idiomatic one! – Yu Shen May 20 '16 at 11:53 — Yu Shen, May 20 '16 at 11:53

score 2 · Answer 2 · edited May 23 '17 at 11:52

Your eventual function is as lazy as it can be. It searches eagerly for the first truthy item then stops. But it has problems:

It fails to terminate on an empty collection. (rest ()) is (), which is truthy. Use next instead of rest. (next ()) is nil, which is falsy.
It is truly recursive. It will blow the stack on a long enough search. Try (eventual (repeat false)). Since the recursion is tail-recursion, you can fix this by using recur in its place.
While we are at it, it is idiomatic to return nil, not false, upon running out of a collection. So drop the final false.

We end up with

(defn eventual [cols]
  (or (first cols) (if-let [rs (next cols)]
                     (recur rs))))

I'm a little queasy about what happens if cols is empty. Code based upon the source for some is clearer:

(defn eventual [coll]
    (when (seq coll)
      (or (first coll) (recur next coll))))

But using (some identity col), as Piotrek suggests, is probably best.

Thanks for finding problems of my implementation, and fixing it. — Yu Shen, May 20 '16 at 11:54

Idiomatic and lazy eventually truthy in a list in Clojure

2 Answers2