I didn't find any library to subscribe to GraphQL from cljs/Node (all of them either use only HTTP or asume you are in the browser), so came up with this, maybe someone finds it useful: https://gist.github.com/polymeris/d20a5a2aad02fa83f36ee0b57ed96496

any ideas how to get around https://dev.clojure.org/jira/browse/CLJ-1625? I wanted to have all protocols in one namespace[1], but that does not work when protocols happen to have same method names 😞 [1] https://github.com/binaryage/chromex/blob/master/src/lib/chromex/protocols.cljs

@darwin having the same name in the same ns is never gonna work. how would the user even distinguish what to call?

@thheller via protocol identifier?

but you call (chromex.protocols/subscribe! ...)? how would there be two or more?

well I’ve never had deep thought about it, I was using protocols with this pattern, and never hit this problem with same names

I was thinking that protocol name is somehow involved in the lookup and it happens under the hood, e.g. chromex.protocols/subscribe! is just a sugar for chromex.protocols/IChromePort:subscribe! if not ambiguous

or something like that

still requires it to be unique (per ns)

no, in case of non-unique names, you’d use full qualification with protocol name in it

the names are unique internally so you can have the same name from different namespaces

nevermind, now I know how it works, and I will have to put procotols into unique namespaces

just choose unique function names in the first place

then you don't have that issue at all 🙂

I cannot in this case, the names are following API names

well you already seem to be bending those rules with subscribe!?

how?

not using -subscribe!?

its not a valid JS API name?

well, I just have a convention how to translate API names into clojure protocol names, I just want it to be consistent

I didn’t want to say, I take them literally

and even without this case, I might strongly want to “reuse” nice names even if I were free to pick my own names

now I have a secondary problem, I decided to bit the bullet and move protocols into separate namespaces, but wanted to produced user-friendly error for someone using my lib and having code using old protocols, something nice with explanation where to find replacements

I was unable to find any solution to this

my first approach: I wanted to emit an error when someone requires chromex.protocols, it worked, except in debug builds all cljs files are compiled, and that was triggering the error even if nothing was using the namespace

my second approach was to mark protocols somehow as “moved”, or forward them to proper places, didn’t find a solution

(ns chromex.protocols) (throw (some-nice-error))

only breaks at runtime though

other than that you can just "forward"

yeah, I wanted compile-time error, but maybe adding this won’t hurt

(ns chromex.protocols) (defn subscribe! [target ...] (something.else/subscribe! target ...))

as far as the calling is concerned that is about equal

not sure if users actually implemented the protocols are used them directly

aha, interesting

no, users are expected only to call stuff, if I recall correctly

from the users perspective a protocol call looks just like a function call so you can swap them easily

thanks for the hints, I think this will be good solution, I will forward all existing protocol methods with a warning, and if someone used protocols for implementation they get some standard compiler warnings about missing protocols and will have to investigate it themselves

why cljs.core always use deftype and never defrecord ?

you don't always need to extra features defrecord provides so deftype is better for those cases

Also, stepping back a little, cljs.core is really defining the fundamental implementation of types, where it is appropriate to use deftype. There's a mini Twitter discussion on the subject here https://twitter.com/mfikes/status/1017840912855117825

Can anyone explain this difference, Clojure vs ClojureScript? With Clojure:

user=> (do (print ".") (print "."))
..nil

cljs.user=> (do (print ".") (print "."))
.
.
nil

@alza-bitz Normally setting *print-newline* to false would be sufficient, but there may be some limitation to the shipping Node REPL.

in Lumo, (do (print ".") (print ".")) acts just as Clojure

@mfikes

$ clojure -Srepro -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.10.439"}}}' -m cljs.main --repl-env node -e '(do (print ".") (print ".") (prn *print-newline*))'
.
.
false

with-out-str works as expected. Can be something with JVM<>Node

~ clojure -Srepro -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.10.439"}}}' -m cljs.main --repl-env node -e '(prn (with-out-str (do (print ".") (print ".") (prn *print-newline*))))'
"..true\n"

@alza-bitz it is printed using console.log which always adds a newline