That is just a map

So on general, unless required for some other reason, you wouldn't make such a thing

Right. I'm trying to let the azure function framework coerce a message into this event map. The blobinput annotation expects this sort of class. Tbh it looks like writing the clojure to avoid this annotation is easier than working with the java event class

I am not familiar with the azure libraries, but the way this kind of thing is often structured there is a high level layer with pojos and annotations for persistence, and then a lower layer which is more data oriented and closer to the actual wire format, which is usually nicer to use from clojure

Ok, thanks. I’ll dig into the docs for the lower layer.

You can look into https://github.com/zonkyio/embedded-postgres

if the sql queries don't use any specific postgres features, you can use h2 in memory. But it's a bit like mocking, with all the associated pitfalls

Good point, we had done some H2 investigation as well. We do use some of those features which tie us to postgres specific items. As a note, when implementing embedded-postgres, you likely want to also look into using https://clojuredocs.org/clojure.test/use-fixtures for lifecycle management during tests

@U02F0C62TC1 @U0247T34DQU curious if you might be able to help with a separate issue https://clojurians.slack.com/archives/C053AK3F9/p1657390667098349

in the docstring for contains? there is a line “‘contains?’ operates constant or logarithmic time; it will not perform a linear search for a value.”

It will be constant for hash-map and logarithmic for sorted-map.

Sweet! Thank you guys! 🙂

If you check for equality* between two sets, is that O(N)? Or is there a faster way to do that? *By "equality" I mean they contain the same elements

https://clojure.org/guides/equality from ^ this guide Both arguments are sets (including Java sets implementing java.util.Set), with = elements, ignoring order. It sounds like O(N) to me

naive benchmark:

(let [s1 (into #{} (range 1000))
        s1' (into #{} (range 1000))
        s2 (into #{} (range 100000))
        s2' (into #{} (range 100000))]
    (time
     (dotimes [_ 1000]
       (= s1 s1')))
    (time
     (dotimes [_ 1000]
       (= s2 s2'))))
  ;; => "Elapsed time: 42.390333 msecs"
  ;; => "Elapsed time: 5667.525708 msecs"

yeah that's what I thought

the two times are a bit more than 100x apart, same as the size of the sets in the two trials

Thanks for showing me that! 🙂

#js tagged literal is not recursive. you have to use it everywhere you want to make JS data stricture instead of Clojure.

(def obj #js {:nested #js {:a 1 :b 2}})

(set! (-> .-nested .-a) 2) ;; => 2

obj ;; => #js {:nested #js {:a 2 :b 2}}

or use clj->js instead of #js

(clj->js {:nested {:a 1 :b 2}})
;; => #js {:nested #js {:a 1 :b 2}}

Now I see, interop is more tricky than I thought:) Thanks for pointing out!