Are you using deps or lein?

deps

Not familiar with deps sry.

https://chat.openai.com/share/1c3a6ead-6fd0-41b9-88af-617004ccafb5

@U058DHAN3UP yes there is! As described in that link you can do it like this in your deps.edn :

{:paths ["src"]
 :deps {... your prod deps ...}
 :aliases {:dev {:extra-deps {djblue/portal {:mvn/version "0.42.1"}}
                 :extra-paths ["dev-src"]}}} 

((clojure-mode . ((cider-clojure-cli-aliases . "dev:dev-tools:testing-tools"))))

Alright nice! That sound do it, thank you

It worked, thanks again!

Logging is one of those "this should be obvious" issues (like unicode, datetime, etc.) that has more tradeoffs and edge-cases the further your dig. If you have no other requirements than what you posted, I would recommend either: 1. More opinionated and "all or nothing" solution - https://github.com/ptaoussanis/timbre 2. Less opinionated and "lego bricks" solution - https://github.com/clojure/tools.logging in your own code + you need to configure a backend (e.g. via https://github.com/pyr/unilog if you don't want to dig too deep into JVM logging)

Thanks I'll look into those

timbre did the trick, thank you! "Just works"!

(defn round-2
  "Rounds to 2 decimal places for the average length"
  [number]
  (with-precision 2 (/ (bigdec number) 1)))

with-precision works with BigDecimal operations. But because your first argument for / not necessarily BigDecimal it might not apply

Ah!

Is there a way to circumvent this or to "cast" my double as a bigdecimal?

look at my example: there is a call (bigdec number)

Ah thank you, I will implement this!

(with-precision 2 (* 1M number)) but precision for BigDecimal is about the number of significant numbers so it's not what you're looking for (and also a bit convoluted) (e.g. the "fixed" version of round-2: (round-2 111) => 110

Ah, yeah that sounds wrong, what I want is something that takes in (say) 23.54214 and returns 23.54

it might not be the optimal way but: (double (.setScale (BigDecimal. number) 2 java.math.RoundingMode/HALF_UP)) or simply multiply for 100, cast to int, and divide by 100 again ?

oh I guess that second part might work I guess

Okay that works, thank you!

significant numbers => I meant significant digits

I went with the multiply cast divide method, it's fine for my purpose since the numbers I'm looking at are all smaller than 50

If it's just for viewing, you can use DecimalFormat

you can use clojure.core.match but inside of a single arity.

Okay, thanks.

Oh intersting, I didn't realize core.match is supposed to be require as clojure.core.match, very strange.

(As opposed to other core things, like core.string.

(defn foo [x]
  (match/match x
    {:left a}  [:left a]
    {:right a} [:right a]))

(foo {:left 1})

Yup, thanks.

it’s just it’s namespace. clojure.string, clojure.core.match . It’s not a “supposed”, just the namespaces they have

makes sense.

one thing. check the macroexpansion. the match library handles lots of stuff. but it might be overkill and slower than you need for this

(macroexpand '(match/match x
                {:left a}  [:left a]
                {:right a} [:right a]))

Oh sure.

That's not the actual pattern I need, its deeper tree patterns.

Basically converting this code to ClojureScript:

(define/match (balance t)
  [(or (tree z 'black (tree y 'red (tree x 'red A B) C) D)
       (tree z 'black (tree x 'red A (tree y 'red B C)) D)
       (tree x 'black A (tree z 'red (tree y 'red B C) D))
       (tree x 'black A (tree y 'red B (tree z 'red C D))))
   (tree y 'red (tree x 'black A B) (tree z 'black C D))]
  [else t])

sketch=> (do
           (let [iters 4000]
             (println "using match")
             (time (dotimes [_ iters] (using-match {:left 1})))
             (println "handrolled")
             (time (dotimes [_ iters] (hand-rolled {:left 1}))))
           (foo {:left 1}))
using match
"Elapsed time: 1254.320042 msecs"
handrolled
"Elapsed time: 1.396541 msecs"
[:left 1]

ah ok then

Is that time including the time it takes to do macro expansion?

Hmm...although it doesn't look like match has or. Oh well. 😞

my first idea would be that whatever the db returns doesn't use keyword keys

The DB returns EDN