Is it possible to create circular references in Clojure ?

Question

Ignoring native interop and transients, is it possible to create any data structures in Clojure that contain direct circular references ?

It would seem that immutable data structures can only ever contain references to previous versions of themselves. Are there any Clojure APIs that could create a new data structure that has a reference to itself ?

Scheme has the letrec form which allows mutually recursive structures to be created - but, as far as I can tell, Clojure does not have anything similar.

This question is related to porting Clojure to iOS - which does not have garbage collection, but does have reference counting.

Answer 1

You can create a circular reference very easily by putting some form of reference inside a data structure, then updating the reference to point back to the overall structure.

A trivial example:

(def a [(atom nil)])

(reset! (first a) a)

This will create a list with one element, which is an atom that points back at the list.

Answer 2

In Clojure most circular data structures will explicitely go through a ref type of some kind (eg atom).

However you can create a circular sequence (it's somewhat an oxymoron):

(let [a (atom nil)] (reset! a (lazy-seq (cons 1 @a))))

And now in 1.2 with deftype you can create other datatypes which can introduce circularity without using explicitely (from the usercode at leats) any kind of ref type.