Using letfn* for defining corecursive reified implementations

Fri, 27 Jun 2025 10:38:18 +0000

I was finding a way to have co-recursive reified instances, and after looking at the implementation of clojure.lang.Compiler I've found out that this can actually be achieved with letfn*. Consider the following proof-of-concept:

(defmacro thunk [& body]
  `(reify* [clojure.lang.IFn]
      (invoke [this] ~@body)))

(letfn* [g (thunk (+ 1 2 3 (f)))
         f (thunk (+ 1 2 3))]
    (f))

This works, and seems to be faster than other state-based approaches (e.g. using atom to resolve forward declarations).

This said, I recognize that this may not be standard behavior. for instance using (reify* ...) directly in the letfn* bindings will cause the reify* block to be parsed as a MetaExpr which breaks a cast in the implementation of LetFnExpr. For example:

(letfn* [g (reify* [clojure.lang.IFn] (invoke [this] (+ 1 2 3 (f))))
         f (reify* [clojure.lang.IFn] (invoke [this] (+ 1 2 3)))] 
  (f))

But since this would implicitly add metadata to the reify* forms we get this error:

class clojure.lang.Compiler$MetaExpr cannot be cast to class clojure.lang.Compiler$ObjExpr (clojure.lang.Compiler$MetaExpr and clojure.lang.Compiler$ObjExpr are in unnamed module of loader 'app')

The only way I've managed to create a reify* form without metadata is by creating the form in macro, such as the thunk macro defined in the first example.

Is using reify* within letfn* bindings supported? If not, are there any other methods that avoid mutable state that could be employed in similar cases?

Returning the last assigned value from `let` w/o a body

Wed, 13 Mar 2024 23:17:32 +0000

This is more of a suggestion, not really sure where to post it though. Please refer me to the relevant forum if there exists a better one.

Basically I'm going under the assumption that no one uses let without a body. The only reason I can imagine for doing that is purely for side-effects, and do etc. are a much better fit, and currently (let [x 1 y 2 z (+ x y)]) => nil (rather than throwing a spec error, as if this is useful expected behavior? But why?)

In any case, if my assumption is correct, then I propose let returns the last assigned value, such that (let [x 1 y 2 z (+ x y)]) => 3, that is z. This is ergonomic, and intuitive in my eyes. It's also especially useful for long binding forms building off of the same variables only for the final one to be important, which then requires a whole row with special funky indentation just for that.

Clojure Q&A - Recent questions tagged bindings

Using letfn* for defining corecursive reified implementations

Returning the last assigned value from `let` w/o a body