Clojure Q&A - Recent questions tagged metalanguage

`eval` using functions with metadata

Mon, 01 Jun 2026 14:33:00 +0000

TIL:

(eval (list + 1 2)) ; works
(eval (list (var-get #'+) 1 2)) ; works
(eval (list (fn [a b] (+ a b)) 1 2)) ; works

(defmacro m [] `(~(fn [a b] (+ a b)) 1 2))
(m) ; also works

;; however, if the function has any metadata:
(eval (list (with-meta + {}) 1 2))
;; ^ fails, No matching ctor found for class clojure.lang.AFunction$1

This was unintuitive to discover.

I solved it locally with a little helper:

(defn val->expr [v]
  (if (symbol? v)
    `'~v
    (cond-> v
      (and (fn? v) (not (nil? (meta v))))
      (-> (with-meta nil)
          (list (-> v meta (update-vals val->expr)))
          (conj `with-meta)))))

But this takes special handling. I wonder if something similar would not be possible on a "matching ctor"-level, possibly also for comp, every-pred?, etc. It would be fairly trivial even in userland to have versions of these functions which carry metadata sufficient to recreate expressions, e.g. comp storing the list of functions, and then eval, on encountering No matching ctor found for class clojure.core$comp$fn__5921, can instead pull out the list of functions from that value and evaluate (list* comp (:composed-fns (meta v))) (or some such) instead.

I think this would be great to have in the core lib, at least for metadata and core libs functions like comp, some-fn, every-pred?, and complement.

Note, I'm not talking about adding or changing ctors for these necessarily. A hook for taking unconstructable values and making a constructable value out of them would serve just as well, maybe even a multifn.

Strictly in userland and without core lib support, I suppose the cleanest way to do something like this is a custom protocol and probably monkeypatch some core libs functions (maybe eval?)

So I suppose my questions are:

Is this something you agree would be good to have in general? Or is this by design for some reason I can't see?
Would this be good and practical to have in the corelib? Oughtn't be a breaking change at least
If no, is there currently any sane way to apply my solution in a more systemic way than wrapping every relevant value with a val->expr call?

Adding support for byte sequences to the EDN standard

Tue, 07 Sep 2021 23:30:50 +0000

How do I get support for byte sequences to EDN? One implementation might be from adopting the mechanism used by Bencode: https://wiki.theory.org/index.php/BitTorrentSpecification#Bencoding

This still requires some context and doesn't allow for top level direct arbitrary binary to be accepted as valid. I'm not sure this is the best method, but I do need some way to represent arbitrary binary blobs well. One thing to also consider is interrupted data, which bencode's approach does not work well with. That might always be an application level concern, I'm not sure.

What do the metalanguage-style symbols on clojuredocs.org mean?

Sat, 19 Jun 2021 15:32:03 +0000

I want to know what the characters mean on the second lines of entries on https://clojuredocs.org.

For example, head on over to https://clojuredocs.org/clojure.core/prn.

The first line of that page is:

prn

The second line is:

(prn & more)

What does (prn & more) mean? How do I interpret that? In particular, how do I interpret the ampersand &?

The notation used here reminds me of the "metalanguage" Augmented Backus-Naur form (https://en.wikipedia.org/wiki/Augmented_Backus–Naur_form), used to express the grammar of a programming language, and of the usage guidance often given by help entries for programs.

However, I don't see any documentation anywhere of how to interpret this particular metalanguage, if that's even what's going on here.

I am especially wondering how to interpret the &.

If there is a page somewhere explaining this, I wish it were linked from every entry on https://clojuredocs.org.