Clojure Q&A - Recent questions tagged protocols

Missing protocol error will hang on infinite `(range)` input in ClojureScript but not Clojure

Fri, 03 Apr 2026 11:16:47 +0000

functions like transient, assoc, etc will throw helpful missing-protocol error when receiving invalid input but it will hang if it receives infinite (range).
this is related to issue below
https://ask.clojure.org/index.php/14578/even-range-hangs?show=14578#q14578

however, missing-protocol only hang in clojurescript but not clojure so I am wondering if this difference is intended.

example calls that should throws
- (transient (range))
- (assoc (range) :a 1)

An undocumented breaking change in data.json

Thu, 23 Oct 2025 17:18:23 +0000

between the versions 1.1.0 and 2.0.0, data.json introduced a breaking change: The JSONWriter#-write signature changed from [object out] to [object out options]
On this commit:
https://github.com/clojure/data.json/commit/8f070ba94dc7c469f303259ce5f5bfa0b53d50bd
In release notes Release 2.0.0 on 2021-Mar-19 , there is no mention to JSONWriter or -write protocol changes.

I know it's a very old problem, but I think this documentation could be present.

Protocol function with placeholder _ arguments doesn't work as in Clojure

Mon, 17 Mar 2025 14:58:32 +0000

A protocol like below will work in Clojure without issue, but in ClojureScript the _'s will apparently (quietly) override each other left to right.

(defprotocol Linkable
  (-href [_ _ _]))

Even if the extend-protocol has unique names for the args, the dispatch seems to happen on the last argument.

Repro at https://github.com/valerauko/proto-repro/commit/a8ad51a225ed44ed134b28a18cc83d272d0d8321

Using distinct argument names in the defprotocol solves the issue. I think if it doesn't / can't work like in JVM Clojure it should warn about this issue.

Hypergraphs, via protocols, perhaps extending loom?

Thu, 09 Nov 2023 02:41:39 +0000

I am exploring clojure implementations of hypergraphs (edges can join > 2 nodes)? i've used loom for graphs, and imagine trying to extend it somehow.

either with loom or without, any suggestions how to use PROTOCOLS for these definitions?

thanks for any suggestions. - RIk

Protocols and eager evaluation in partial

Tue, 08 Aug 2023 23:56:17 +0000

The bug CLJ-2094 demonstrates an edge case with protocols stemming from functions like partial eagerly evaluating their arguments and thus retaining outdated references. I ran into this recently and found that the ticket had been declined because of "normal Clojure evaluation rules".

I think there's an easy fix for protocols that adds very little overhead and allows protocol-related functions to work in both eager and lazy evaluation contexts. Would the team be interested in a patch for this?

Allow clojure.core/extend to take a regular map as proto+mmaps parameter (today it's just "kwargs")

Sat, 11 Mar 2023 17:02:27 +0000

Often, when you call clojure.core/extend directly (vs extend-type, extend-proto or inline definitions), that means you have some level of composition that happened upstream to create proto extensions for a type.

To recap today the signature of extend is as follows:

([atype & proto+mmaps])

Meaning when it's called it looks like

(extend t protoA {...} protoB {...})

I am advocating to just changing it to

([atype & {:as proto+mmaps}])

That would allow somebody calling into extend to pass either an "unrolled" map like today, or a regular map to it (leveraging the recent patch from @fogus).

(extend t {protoA {...} protoB {...}}) and (extend t protoA {...} protoB {...}) would be supported.

The alternative today when you have a proto+mmaps that is the result of merging implementations is to do something akin to:

(apply extend t (into [] cat proto+mmaps))

the patch would allow to do things such as:

(extend t (merge proto-impl-a proto-impl-b proto-impl-c ...))

I am happy to provide a patch for this if that's considered to be an acceptable change.

Would it make sense to have a flag to cache protocol implementation lookups?

Mon, 25 Apr 2022 13:02:50 +0000

In recent conversation I learned that some developers avoid and discourage the use of satisfies? because of performance concerns. I was told to "just look at the implementation, you will sweat bullets".

The implementation in this case is in find-protocol-impl which has to check metadata, traverse the inheritance chain as well as implemented interfaces.

The part of finding a protocol implementation for a specific class seems emminently cacheable, except for the fact that one can extend the protocol later on.

Would it make sense to cache this, and have extend-* invalidate the cache? Or alternatively to have a flag (e.g. -J-Dclojure.cache-protocols=true) for use in production where you know all protocol implementations will be loaded before lookups happen?

Emit named functions in protocols and extend macros

Thu, 02 Dec 2021 18:55:01 +0000

Is it possible to add names to the functions emitted by defprotocol and the various extend-* macros?
It would make anything involving stack traces, from exceptions to profiling, more informative

When does a metadata protocol extension get chosen?

Wed, 22 Sep 2021 20:23:51 +0000

It seems like a metadata protocol implementation overrides extend calls, but not direct implementations. Is this expected? How does choosing a metadata protocol interact with the caching of defprotocol methods? Are there any other gotchas?

Clojure 1.10 .3
user=> (defprotocol A :extend-via-metadata true (foo [this]))
A
user=> (defrecord Direct [] A (foo [_] :direct))
user.Direct
user=> (foo (->Direct))
:direct
user=> (foo (with-meta (->Direct) {`foo (fn [_] :meta)}))
:direct
user=> (defrecord Extend [])
user.Extend
user=> (extend-protocol A Extend (foo [_] :extend))
nil
user=> (foo (->Extend))
:extend
user=> (foo (with-meta (->Extend) {`foo (fn [_] :meta)}))
:meta

Record refinement feature

Sat, 19 Dec 2020 21:42:33 +0000

My project depends on library "lib".
This library has a protocol lib.core/P with 10 functions and a record lib.core/R implementing the protocol.
In my project I need a record my.core/Q that is a lot like R: out of the 10 functions just 1 is different.

What are my options for implementing Q:
a) Copy paste the other 9 functions from R.
b) What else?

Would a "record refinement" feature of sorts be worthwhile?

(defrecord Q [a b c]
  :refines lib.core/R
  lib.core/P
  (just-my-one-changed-fn [] ...))

Implementing a type or record to support defmethod in CLJ

Fri, 17 Jan 2020 18:37:33 +0000

Thanks to IMultiFn in CLJS types and records can be easily extended to behave as multimethods. For example:

`(defrecord MyMulti
[add-method remove-method dispatch-fn method-table]
IMultiFn
(-add-method [_ dispatch-val f]

(add-method dispatch-val f))

(-remove-method [_ dispatch-val]

(remove-method dispatch-val))

(-methods [_] @method-table))

(def my-multi (->MyMulti ...))

(defmethod my-multi :foo
[x]
...)
`

In Clojure however this isn't as easy because multimethods are not implemented using protocols. IS there ANY way to make a record or type to work with defmethod in CLJ?

Thanks!