(require 'clojure.stacktrace) -- not sure why you have parens around it?

build=> (require 'clojure.stacktrace)
nil
build=> clojure.stacktrace/print-throwable
#object[clojure.stacktrace$print_throwable 0xebfa509 "[email protected]"]
build=> (doc clojure.stacktrace/print-throwable)
-------------------------
clojure.stacktrace/print-throwable
([tr])
  Prints the class and message of a Throwable. Prints the ex-data map
  if present.
nil

I see. I nearly always use it with ns, so I got confused.

If I require with parens like your example, I get that same exception (but that's not legal require syntax, right?)

I was confused that it returned nil.

OK, that explains 🙂 Thanks @U04V70XH6

You can (require '[clojure.stacktrace]) as a vector...

(~/clojure)-(!2002)-> clj
Clojure 1.11.1
user=> (require '[clojure.stacktrace])
nil
user=> clojure.stacktrace/print-throwable
#object[clojure.stacktrace$print_throwable 0x4acf72b6 "[email protected]"]
user=>

Wed Mar 15 17:23:44
(~/clojure)-(!2003)-> clj
Clojure 1.11.1
user=> (require '(clojure.stacktrace))
nil
user=> clojure.stacktrace/print-throwable
Syntax error (ClassNotFoundException) compiling at (REPL:0:0).
clojure.stacktrace
user=>

Yeah that's it, I confused the vector syntax.

maybe I should me using defmulti/defmethod instead of relying on deftype and protocols? or not?

I want to evolve the implementation of my protocol without rebuilding my instances which contain state like network connections

maybe the usual repl flow is to map->Class after reevaluating the defrecord ?

Let's start with - why use records and types to begin with in your use case?

to implement a protocol ensuring the abstractions are used, and to have runtime polymorphism

What sort of thing are you abstracting over? Data or state and operations? Even with protocols you have several options, including extend-protocol and extension via metadata It's rare to need new concrete types in Clojure If it's just data, multimethods may be better Also see https://github.com/cemerick/clojure-type-selection-flowchart

A component that I want to be able to swap for another implementation or a mocking implementation. It started as just immutable data but is evolving to state, by keeping maps to connect implementation behaviors to abstractions inside the app's domain. I had started with deftype and moved now to defrecord, but yeah I'm still a bit lost

Why not just use function as an interface?

Also,regarding swappable implementation, have you seen the Component library?

I've seen it from a distance, haven't dug in at all. With defmulti ? Right maybe that's it. Though then I wonder how I'd "ensure" that all implementations implement the full thing

maybe I just need to give up that line of thinking of locking things down

sorry I've been too abstract -- to make this more concrete, imagine a communication abstraction over IRC and Matrix

but regardless, imagining whatever use-case that for sure would require deftype for example, I wonder how people keep the REPL quick redefinition dev approach given the instances are not updated

that's what I'm mostly curious

In that case multimethods are usually used You can also take apart building messages and sending them, then have a single client protocol with a single method (send) and a multimethod for building messages of different types

Make protocols for what can be locked down early, you identified something interesting

Hmmmm okay. Makes sense, as I don't know what I want the interface to be like yet. I wonder if it's not a common practice also to have deftypess (as an example) that end up just proxying calls to isolated functions, so implementations remain uncoupled. I guess in the end there's no difference, except the proxying would make redefining easier, so probably not. Thanks for reaching back.

Deftypes are rare, we usually Just Use Functions (TM) until we have a good reason not to

id pretty much use what you said ->. dont see much of a value in having something more

look at comp

((comp fn3 fn2 fn1) data)

reduce is handy if the list of functions should be treated as data..

(def f [vector list])
(def data 42)
(reduce 
  (fn [a f] (f a)) 
  data 
  f) ;; => ([42])

@U0HG4EHMH Thanks. That's what I want

comp can be used with a list of functions:

((apply comp (reverse f)) data) ;; => ([42])

amazing @U04V4KLKC This code is even less:+1:

(defn euler->quat
  "Yaw, Pitch, Roll order (ZYX) - angles in degrees.
   Output in x y z w quaternion."
  [& args]
  (let [ypr (mapv #(/ (m/to-radians %) 2) args)
        [cos-y cos-p cos-r] (mapv m/cos ypr)
        [sin-y sin-p sin-r] (mapv m/sin ypr)
        ...]))

I actually like your code @U04R06XSJV7. It looks very clear and reads nicely.

making the let bindings on top more compact like @U01RL1YV4P7 does, makes sense to me as well. It's a bit more compact and more nicely grouped. But your initial code looks perfectly fine to me.

My 2cents about performance: destructuring kills it, type hinting helps a lot. You may turn on (set! *unchecked-math*** :warn-on-boxed) to verify if you work on primitives (certainly not). Regarding the code structure - for me it's really good and clean.

Maybe you can divide y, p and r by 2.0 at the moment of defining them.

(defn degrees->rad
  ^double [^double degrees]
  (/ (* Math/PI degrees) 180.0))

(defn euler->quat
  "Yaw, Pitch, Roll order (ZYX) - angles in degrees.
   Output in x y z w quaternion."
  [^double yaw ^double pitch ^double roll]
  (let [y (/ (degrees->rad yaw) 2.0)
        p (/ (degrees->rad pitch) 2.0)
        r (/ (degrees->rad roll) 2.0)
        cos-y (Math/cos y)
        cos-p (Math/cos p)
        cos-r (Math/cos r)
        sin-y (Math/sin y)
        sin-p (Math/sin p)
        sin-r (Math/sin r)
        w (+ (* cos-r cos-p cos-y) (* sin-r sin-p sin-y))
        x (- (* sin-r cos-p cos-y) (* cos-r sin-p sin-y))
        y (+ (* cos-r sin-p cos-y) (* sin-r cos-p sin-y))
        z (- (* cos-r cos-p sin-y) (* sin-r sin-p cos-y))]
    (q/quaternion x y z w)))

Here’s my quaternion code in Clojure… https://github.com/mentat-collective/emmy/blob/main/src/emmy/quaternion.cljc

Emmy takes the approach of writing code using multimethods, but then compiling down to a fast representation for end uses

https://www.johndcook.com/blog/2021/06/16/faster-quaternion-rotations good reading too!

Thanks, your opinions are invaluable to me!

if you want speed, the data science clojure group (on slack and more on zulip) can probably help, as they are familiar with libs that use the GPU for math (eg: Neanderthal)

Will check that out, thank you!

It's probably convenient to def a few aliases:

(def at-context (keyword "@context"))
(def at-type (keyword "@type"))

... (get doc at-context) ... (get doc at-type) ...

Or you could just do that "in-place": ((keyword "@context") doc) ;=> (:@context doc) ;=> value of @context field.

It worked! Thanks! 😀

One option is for those services to return the (ex-info ..) result instead of throwing it, then somewhere in your processing of the results, see if you got (instance? Exception result) and if so, (throw result)

(Exceptions as "just" values so you can pass them around)

But since you're doing everything async up until the <!!, you probably won't be able to throw overall until after you have that vector of results.

thanks for your response Sean

Well, if you had ONE set and one vector, you could use (filter some-set the-vector) because Clojure sets work as a lookup function. (Which vectors do not; it would encourage linear searching.) Given two vectors, you had better convert one (maybe the smaller one) to a set in order to get fast lookups. If your vectors are so short that you don't care about fast lookups, then conversion to a set will also be a non-concern. So: (filter (set vector-a) vector-b) ... in short, you don't need clojure.set for intersection.

Whaaaat? That's wild!

Exactly what I was looking for. Cheers @U0HG4EHMH!

Clojure doesn't stop to surprise me 🙂

> Whaaaat? That's wild! The Clojure experience, in a nutshell!

Hahaha yeah. I'm loving it! But my head spins like crazy at times that's for sure.

Had to do some JS (which I normally like), but after Clojure I was like what? Syntax? F*ck that!

(let [coll [[:a :b] [:b :c] [:d :b]]]
  (reduce (comp set filter)
          (-> coll first set)
          (rest coll)))

JS sets are cool. Unfortunately [1, 2] != [1, 2]

I'm on CLJS for all that now 🙂 Starting a new project, it has a tight deadline, my CLJ skills aren't great (but I get by), I was considering it and was like I want to work with CLJ no matter what, so here I am! Moonlighting to learn, to fill in gaps in my skills, but really loving it.

I find that requiring clojure.set doesn't come up too often for me, and I use the set functions a lot, just not in most namespaces. I think set/intersection is more informative than the filter example, which is more like a clojure idiom.

Hahaha totally, but I appreciate the short version.