@U4YGF4NGM on require would be fine with me (I've done the same with protocols and specs)

Why not both? A .core ns with the install function (which I would name start and plug it into Component/etc client-side) and a .auto ns that calls (start) at compile-time So consumers can choose their prefered approach

From my side I don't like to be one tooling-config mistake away from a prod issue, has happened to me, never again

{:aliases {:dev {:extra-paths ["dev"]}}}

tools.deps doesn’t have a direct :init-ns equivalent.

(Note that having user.clj load your app’s entry point namespace might impact your REPL startup time pretty significantly, though: https://blog.flowthing.me/clojure-repl-start/)

@U96DD8U80 Would this satisfy you?

seanc@Sean-win-11-laptop:~/clojure$ cat deps.edn
{:aliases
 {:dev {:extra-paths ["dev"]
        :main-opts ["-e" "(do (require 'startup) (in-ns 'startup))" "-r"]}}}
seanc@Sean-win-11-laptop:~/clojure$ cat dev/startup.clj
(ns startup)
(println "Starting up dev...")
seanc@Sean-win-11-laptop:~/clojure$ clj -M:dev
Starting up dev...
#object[clojure.lang.Namespace 0x1827a871 "startup"]
startup=>

Obvs the :dev alias could require any ns and jump into it.

https://github.com/vvvvalvalval/supdate

Also. I'm using ClojureScript. For any library suggestions.

Ah, and the library by that link already mentions Specter.

specter does a lot more, but also is a DSL that requires a bit of learning

supdate looks pretty spot on. I think I like it's syntax for updating all values in a vector better than the idea I had for it.

it's syntax is similar to pattern matching, you may be interested in core.match https://github.com/clojure/core.match

It works like charm!

I still like Specter's solution here and I think it's worth learning for performance as well as power.

(multi-transform (multi-path [:b :y ALL]
                             [:c])
                 str
                 m)

I haven’t checked in a few years, is there a more systematic way to learn specter yet besides constantly pestering Nathan with questions?

I was pretty happy with its guide, examples, and source code.

@U02KYBC5WJY Spectre looks pretty rad. I think it could be great material for your audience. Just sayn'. Seems like you could recruit someone to record with in this thread. 😃

core.match is also pretty mind blowing, btw.

Medley has considered adding a fn that lets you use update as a sort of mini-language for nested updates, I think it’s rather elegant https://github.com/weavejester/medley/issues/63#issuecomment-1112233476

It probably shouldn't surprise me that we have this abundance of options, but anyway, it amazes me. 😃 This is the example from that medley PR solved with supdate:

(def m {:users [{:id 1 :orders #{{:items [{:price 1} {:price 4} {:price 2}]}}}
                {:id 2 :orders #{}}]}) 
(-> m 
    (supdate {:users [{:orders [{:items [{:price #(str "$" %)}]}]}]})
    (supdate {:users [{:orders set}]}))
=>
{:users [{:id 1 :orders #{{:items [{:price "$1"} {:price "$4"} {:price "$2"}]}}}
         {:id 2 :orders #{}}]}

the syntax looks a bit like dataomic pull/ednQL. i think you probably identified a bug, though. i don't like it when high level DSLs change my types, and clojure has an ok way of preserving types via (->> my-obj transform-fn (into (empty my-obj)) clojure.walk is a good example of transformation code that doesn't change types. seems like a good bug to report

https://github.com/turtlegrammar/faconne this is a really cool idea i came across when searching around for declarative data transformations. this lib does have some common edge cases where it breaks (seems to fail on nil cases). i think the self documenting syntax is pretty elegant.

> seems like a good bug to report https://github.com/vvvvalvalval/supdate/pull/9

Thanks all for bringing supdate to my attention! I think it's a more comfortable alternative to threading macros (e.g. in event handlers for shadow-grove or re-frame). I do need assoc though, so I'll probably just fork the supdate* fn and keep it simple for now.

Here's what I ended up with:

(dtf
    {:a 1
     :b {:c 3 :d #{4}}
     :e :replace-with-num
     :f :replace-with-vec
     :g :replace-with-set
     :h :replace-with-map}
    {:a dissoc
     :b {:c inc :d [inc]}
     :e 6
     :f (constantly [3 4])
     :g #{1 2}
     :h (constantly {"a" "b"})
     :new {:foo :bar}})
  := {:b {:c 4, :d #{5}}
      :e 6
      :f [3 4]
      :g #{1 2}
      :h {"a" "b"}
      :new {:foo :bar}}