Does Clojure have "unfold"?

Question

(defn unfold [step seed]
  (if-let [[val new-seed] (step seed)]
    (cons val (lazy-seq (unfold step new-seed)))
    nil))

Example usage:

(defn fib-step [[x y]] [x [y (+ x y)]])
(take 10 (unfold fib-step [0 1])) ;=> (0 1 1 2 3 5 8 13 21 34)

(defn decreasing [x] (if (neg? x) nil [x (dec x)]))
(unfold decreasing 5) ;=> (5 4 3 2 1 0)

Does this or something like it exist in clojure standard (or commonly used) libs? If not, is there a reason why? The closest I've found is this blog post:

http://www.matlux.net/blog/2014/05/04/anamorphic-adventure-in-clojure

Answer 1

No, unfold is not implemented in Clojure. It is provided by amalloys flatland.useful library, which has wide usage according to CrossClj. Seeing as the blog post you linked provides quite a deep exploration of the subject, I suspect there is more to your question than a direct answer can satisfy... Do you have some scenario in mind where iterate is inadequate? Or disappointed that iterate is not quite unfold in name or behavior?

(defn fib-step [[a b]] [b (+ a b)])
(take 10 (map first (iterate fib-step [0 1])))

(take-while (complement neg?) (iterate dec 5))

I prefer to use iterate for these examples because iterate is part of core already. I can see people preferring unfold if that is more familiar to them.

There are many libraries that provide "things that should have been in core" such as https://weavejester.github.io/medley/medley.core.html. A quick search on https://crossclj.info/ reveals https://github.com/amalloy/useful contains flatland.useful.seq/unfold, which though I have not used looks to be a great implementation by a Clojure core contributor and comes with some other cool stuff to boot.