How do I add schema annotations to defprotocol?

[scramjet]

I'm translating a bunch of doc comments into Schema, but immediately hit the issue: how do I annotate our (copious) protocol definitions?

I'd like something like:

(s/defprotocol ICodec
  (encode-inquiry [this property :- Property]) :- [Byte]))

Is this possible some other way? Or maybe it's in the too hard basket? (I can see this wouldn't necessarily be easy, possibly requiring interfacing with the Clojure compiler).

[w01fe]

There's no built-in support currently -- I think in principle it should be possible because Clojure effectively emits wrapper fns that could be s/fn, but digging into the implementation this would require copy-pasting or re-implementing a bunch of code from clojure.core that would make me feel pretty dirty.

The easy hack for now is to define your protocol methods like encode-inquiry* and then s/defn an encode-inquiry wrapper that just calls through to encode-inquiry*.

[scramjet]

Thanks. I might have a quick poke around to get an idea of what's involved in the defprotocol implementation. Even if I could have a s/defprotocol that accepts the syntax and spits out a standard clojure.core/defprotocol, that would be a start.

The easy hack for now is to define your protocol methods like encode-inquiry* and then s/defn an encode-inquiry wrapper that just calls through to encode-inquiry*.

I don't really want to change the protocol interfaces and break a bunch of places that implement them.

[expez]

How about just creating a shim so we can add schemas for documentation purposes and then let the next maintainer worry about validations? :D

[w01fe]

@expez you can always put the schemas in the protocol docstring :/. I worry that allowing annotations that behave differently than in all other schema constructs would cause more harm than good.

[dmitrig01]

Another way would be to do it in defrecord – since you may be using a protocol from somewhere else, which doesn't have validation defined.

If you were dto do it in defprotocol, you'd have to add the validation in defrecord anyway, since that's where the functions themselves reside. This does something vaguely similar – redefines some functions inside defrecord to allow varargs: https://gist.github.com/sunng87/372a0a45a07357569eb6. We may be able to do something similar here.

[dmitrig01]

Ok – I have a code snippet which does it – I don't know where the best place to put it in the schema codebase is though...

(defn remove-doc [arg-lists]
  (if (string? (last arg-lists)) (butlast arg-lists) arg-lists))

(defn doc [arg-lists]
  (if (string? (last arg-lists)) [(last arg-lists)] []))

(defn strip-types [arglist]
  (loop [acc []
         arglist arglist]
    (if (empty? arglist)
      acc
      (if (= (first arglist) :-)
    (recur acc (rest (rest arglist)))
    (recur (conj acc (first arglist)) (rest arglist))))))

(defn make-defn [[name & arglists]]
  `(s/defn ~name
     ~@(doc arglists)
     ~@(map (ƒ [arglist] `(~arglist (~(symbol (str "." name)) ~@(strip-types arglist)))) (remove-doc arglists))))

(defmacro defprotocol [name & sigs]
  `(do
     (clojure.core/defprotocol ~name ~@(map (ƒ [[name & arg-lists]]
                                              (concat [name] (map strip-types (remove-doc arg-lists)))) sigs))
     ~@(map make-defn sigs)
     ~name))

[w01fe]

Thanks -- can you explain a bit more what this does? If it just strips types, as I mentioned above we'd be very hesitant to introduce a single schema macro that has different validation syntax than all the existing macros. That said, we welcome third-party schema extension projects, which we think are a great way to prove out ideas which might ultimately make it into core.

[dmitrig01]

sorry – my bad

(macroexpand-1 '(defprotocol ABCD (foo [_] [_ a :- s/Int] [_ a :- s/Int b :- s/Int])))
; =>
(do
   (clojure.core/defprotocol ABCD
     (foo [_] [_ a] [_ a b]))
   (schema.core/defn foo
      ([_] (.foo _))
      ([_ a :- s/Int] (.foo _ a))
      ([_ a :- s/Int b :- s/Int] (.foo _ a b)))
   ABCD)

[dmitrig01]

basically, pretty much exactly what you described above :-)

[w01fe]

Ah, I see. But unfortunately, I think by overwriting foo you lose the "protocol nature" of foo -- I'm pretty sure it will only work on types that implement the interface ABCD directly, and not types that are extend-ed to it later. Does that make sense?

[dmitrig01]

Ahh, intersting. That would explain why what I was trying was working – lemme run some tests and see...

I know, though, if you do (.foo XXX), it won't validate – you hvae to do (namespace-of-protocol/foo XXX)

[SevereOverfl0w]

Worth noting that core.typed has this feature, no idea if that would help as a source of inspiration for implementation.

[djha-skin]

+1, I'd love to see this happen :) great work people