Clojure Q&A - Recent questions tagged protocol

Implement ^:async (CLJS) for protocol functions and multi-methods

Sun, 19 Jul 2026 11:53:45 +0000

In ClojureScript (as of 1.12.145) one can declare a function (defn, fn) to be async by adding the metadata ^:async. However, the same is not applicable to protocol functions and multi-methods. Since async is an invocation semantic, should it be carried over to protocol functions and multimethods? (If yes, should it apply to the protocol definition in defprotocol or to the protocol implementation in reify?)

If async is not to be allowed in protocol functions and multimethods, then the documentation should clearly mention the omissions, alternatives and workaround.

Accidentally specifying a protocol multiple times in deftype may omit some method implementations

Tue, 31 Oct 2023 21:46:44 +0000

If you accidentally specify a protocol multiple times in a deftype form, some method implementations of that protocol may be omitted.

Repro:

(defprotocol P (f [this]) (g [this]))

(deftype T []
  P
  (f [this] :F)
  P
  (g [this] :G))

(def t (->T))

(f t)
;; Execution error (AbstractMethodError) at user/eval187 (REPL:1).
;; Receiver class user.T does not define or inherit an implementation of the resolved method 'abstract java.lang.Object f()' of interface user.P.

(g t) ;=> :G

You can confirm by macroexpanding the deftype form that some of the method implementations are ignored:

(macroexpand '(deftype T [] P (f [this] :F) P (g [this] :G)))
;=> (let* [] (deftype* user/T user.T [] :implements [user.P clojure.lang.IType] (g [this] :G)) (clojure.core/import user.T) (clojure.core/defn ->T "Positional factory function for class user.T." [] (new user.T)) user.T)

It seems like the root cause boils down to parse-impls:

(#'clojure.core/parse-impls '(P (f [this] :F) P (g [this] :G)))
;=> {P ((g [this] :G))}

In my opinion, it would be nice if deftype would check to see if the same protocol is specified more than once and throw an error if so. Otherwise the method implementations should not be ignored without any warning, I think.

Should extenders also list types that extend a protocol via deftype?

Fri, 25 Mar 2022 19:01:40 +0000

I was playing around with protocols at the REPL and encountered the following:

(defprotocol IGreeter
  (greet [this]))

(deftype MyGreeter []
  IGreeter
  (greet [_] "hi from MyGreeter"))

(extends? IGreeter MyGreeter)
;=> true

 ;; I expected to see MyGreeter listed here, but result is nil
(extenders IGreeter)
;=> nil

Now extend the protocol to a few types.

(extend-protocol IGreeter 
  String 
  (greet [this] "hi-string")
  clojure.lang.Symbol 
  (greet [this] 'hi-sym)  ; ' help syntax highlighter
  clojure.lang.Keyword
  (greet [this] :hi-kw))

(extenders IGreeter)
;=> (java.lang.String clojure.lang.Symbol clojure.lang.Keyword)

String, Symbol and Keyword show up as extenders of IGreeter. MyGreeter does not. This was especially surprising since (extends? IGreeter MyGreeter) returns true. Am I misunderstanding something or could this be a bug? Thank you!

How should I correctly detect a protocol symbol in a macro targeting CLJS?

Fri, 25 Jun 2021 00:03:30 +0000

Up through Clojurescript 1.10.844, I could reliably tell whether a symbol sym (at macro-expansion time) referred to a protocol by examining the following:

(:protocol-symbol (cljs.analyzer.api/resolve &env sym))

As of the commit for CLJS-3276, this no longer works in my code. As far as I can tell, defprotocol still attaches this data, and cljs.core still uses this method internally. Is there a better / supported way to detect whether a symbol refers to a protocol? I'm very much hoping that this behavior is reintroduced, or else that there is some other reliable method.

Better stacktraces for protocol methods

Tue, 10 Nov 2020 05:30:20 +0000

Currently extend-protocol-defined functions look like this in the stacktrace:

at app.core$eval3547$fn__3548.invoke(core.clj:23)
at app.core$eval3522$fn__3523$G__3513__3532.invoke(core.clj:14)

Needless to say these aren't exactly descriptive. Not to mention the lines it refers to are where extend-protocol and defprotocol were called, not where the function definition is.

I'd hope for something like app.core/MyProtocol/IfaceImplemented/function_name_1234 with the line number where the "offending" piece of code is, not the definition.

I hacked at it a little locally and found that changing emit-method-builder, emit-impl and emit-hinted-impl a little made the stacktraces much more readable.

Hack diff:

diff --git a/src/clj/clojure/core_deftype.clj b/src/clj/clojure/core_deftype.clj
index 786f0d4b..73570dbf 100644
--- a/src/clj/clojure/core_deftype.clj
+++ b/src/clj/clojure/core_deftype.clj
@@ -586,9 +586,10 @@
 
 (defn- emit-method-builder [on-interface method on-method arglists extend-via-meta]
   (let [methodk (keyword method)
-        gthis (with-meta (gensym) {:tag 'clojure.lang.AFunction})
-        ginterf (gensym)]
-    `(fn [cache#]
+        gthis (with-meta (gensym (str method)) {:tag 'clojure.lang.AFunction})
+        ginterf (gensym)
+        giface-name (gensym (last (.split (name on-interface) "\\.")))]
+    `(fn ~giface-name [cache#]
        (let [~ginterf
              (fn
                ~@(map 
@@ -812,9 +813,21 @@
                    (:var proto)))))
     (-reset-methods (alter-var-root (:var proto) assoc-in [:impls atype] mmap))))
 
+(defn- iface-fn-name
+  ([p f]
+   (iface-fn-name "" p f))
+  ([c p f]
+   (let [c-name (cond
+                  (symbol? c)
+                    (last (.split (name c) "\\."))
+                  (nil? c)
+                    "nil"
+                  :else nil)]
+     (symbol (str p (when c-name (str "__" c-name)) (first f))))))
+
 (defn- emit-impl [[p fs]]
   [p (zipmap (map #(-> % first keyword) fs)
-             (map #(cons `fn (drop 1 %)) fs))])
+             (map #(cons `fn (cons (iface-fn-name p %) (drop 1 %))) fs))])
 
 (defn- emit-hinted-impl [c [p fs]]
   (let [hint (fn [specs]
@@ -826,7 +839,7 @@
                               body))
                       specs)))]
     [p (zipmap (map #(-> % first name keyword) fs)
-               (map #(cons `fn (hint (drop 1 %))) fs))]))
+               (map #(cons `fn (cons (iface-fn-name c p %) (hint (drop 1 %)))) fs))]))
 
 (defn- emit-extend-type [c specs]
   (let [impls (parse-impls specs)]

Logs after:

at app.core$eval3965$ProtocolName__ClassName__FnName__3966.invoke(core.clj:23)
at app.core$eval3940$ProtocolName3932__3941$__FnName3930__3950.invoke(core.clj:14)

Why does an atom not implemented the "ISwap" protocol?

Wed, 06 May 2020 18:19:56 +0000

Why does an atom not implemented the "ISwap" protocol?

It's the swap! implementation:

(defn swap!
  ([a f]
   (if (instance? Atom a)
     (reset! a (f (.-state a)))
     (-swap! a f))))

It's not about optimization because GCC does not inline the swap! call.

;; clj -m cljs.main --optimizations advanced -co '{:pseudo-names true}' -c example.core

(let [a (atom 0)]
  (swap! a inc)
  (js/console.log @a))

var $a_528$$ = new $cljs$core$Atom$$;
$cljs$core$swap_BANG_$$.$cljs$core$IFn$_invoke$arity$2$($a_528$$, function($x$jscomp$125$$) {
    return $x$jscomp$125$$ + 1
});
console.log($cljs$core$_deref$$($a_528$$));

What is an order of protocol methods lookup in protocol implementation for types having subclass relationship

Mon, 07 Oct 2019 16:24:49 +0000

Hi!

Here is a code from honeysql:

(extend-protocol ToSql
  #?(:clj clojure.lang.Keyword
     :cljs cljs.core/Keyword)
  (to-sql [x]
    (let [s (name x)]
      (case (.charAt s 0)
        \% (let [call-args (string/split (subs s 1) #"\." 2)]
             (to-sql (apply call (map keyword call-args))))
        \? (to-sql (param (keyword (subs s 1))))
        (quote-identifier x))))

  .... ;SKIPPED

  #?(:clj Object :cljs default)
  (to-sql [x]
    #?(:clj (add-anon-param x)
       :cljs (if (sequential? x)
               (seq->sql x)
               (add-anon-param x)))))

Assume i'm calling

(to-sql :column-name)

Method selected to be called depends on lookup order because Keyword is a subclass of Object and :column-name IS-A Keyword and IS-A Object.

I didn't find any info about defined order of methods lookup in clojure protocol documentation.

Also i investigated implementation of extend-protocol and as i understood there is a usual HashMap for :impls where all methods are stored so again there is no any guarantee about order of lookup.

Another words, what are the rules of extending protocol for types which have subclass relations or maybe this is not correct at all and i should extend protocol only for types which don't have any type relations.

Thanks!

regex equality

Sat, 07 Sep 2019 14:03:23 +0000

How to check regexp equality in nested structures?

(= #"." #".") ;; #=> false
(= [#"."] [#"."]) ;; #=> false
(= ["."] ["."]) ;; #=> true

I believe that a regexp is a value object.
So two regexp are equal if they equals literally.

Is it possible to update = function for regexp equality support?

Maybe like this:

(defprotocol IEquals
 (equals [a b]))

(extend-protocol IEquals
  Object
  (equals [a b] (.equals a b))
  
  Pattern
  (equals [a b]
    (and
      (instance? Pattern b)
      (= (str a) (str b)))

And clojure.lang.Util.equiv uses
IEquals#equals instead of Object#equals.
But I down know how to call protocol method from clojure.lang.Util.

Protocol implementations via metadata: ClojureScript behaves differently from Clojure

Sat, 31 Aug 2019 07:05:57 +0000

If you extend a type to implement a protocol, and then create an instance of that type that carries its own implementation of the same protocol in its metadata, ClojureScript will still use the implementation from the type, whereas Clojure uses the more specific metadata implementation.

Here's a brief example based on one of the tests for ClojureScript's protocol metadata implementation.

Edit: I am unable to make the code sample presentable in this editor, please see this gist instead: https://gist.github.com/cjohansen/a24257ecb5db15c7e20aaa25ff713b30

(defprotocol ExtMetaProtocol
:extend-via-metadata true
(ext-meta-protocol [x]))

(ext-meta-protocol (with-meta {} {`ext-meta-protocol (fn [_] 1)})) ;;=> 1

(extend-type clojure.lang.PersistentArrayMap
ExtMetaProtocol
(ext-meta-protocol [m]

2))

(ext-meta-protocol {}) ;;=> 2
(ext-meta-protocol (with-meta {} {`ext-meta-protocol (fn [_] 1)})) ;;=> cljs => 2, clj => 1

Replacing core interfaces with protocols

Sun, 04 Aug 2019 16:04:40 +0000

Currently IFn, IDererf etc implemented as interfaces in clojure but these are protocols in clojurescript.
Are there any plans to fix this mismatch?