(defn annual-balance-update   "Calculate balance update"   [balance]   ( balance (+ (bigdec ( (interest-rate balance) 0.01)) 1)))

Thank you!

you can use triple-backtick to get a multiline code fragment in slack 🙂

Hello, World!

Thank you Lennart, I edited my post according to your suggestion to make it easier to read.

Just for my understanding, the fix was to convert to bigdec earlier in the process so precision isn't lost?

Can you give an example of what map-of-maps looks like?

{:k1 foo :k2 bar, :k3 {:inner-k1 foo, :inner-k2 "correct map", :inner-k3 bar}, :k4 quux, :k5 {:inner-k1 foo, :inner-k2 "wrong map", :inner-k3 bar}}

oh that did not let me fix the formatting

The outer map has some irrelevant key-value pairs. There is 1 singular inner map which is important, but is only denoted by the "important value" inside the map.

There are two inner maps with "important value" there?

sort of

i only want 1 of the inner maps.

the other inner maps will not have the same value at :inner-k2

So you want one inner map whose :inner-k2 equals "important value"?

Or, no.

Right, I was just about to say that your example input doesn't really match with what you're saying. 🙂

in that example, i need to extract :k3 's value, where :inner-k2 is "correct map"

Gotcha.

In another case, i may need the map at :k5 instead, but that's another day

If you just want to avoid the intermediate lazy seq, you can use the transducer arity of into:

user=> (def map-of-maps
         {:k1 {}
          :k2 {}
          :k3 {:inner-k1 "foo" :inner-k2 "correct map" :inner-k3 "bar"}
          :k4 {}
          :k5 {:inner-k1 "foo" :inner-k2 "wrong map" :inner-k3 "bar"}})
#'user/map-of-maps
user=> (into {}
         (filter (comp #{"correct map"} :inner-k2 val))
         map-of-maps)
{:k3 {:inner-k1 "foo", :inner-k2 "correct map", :inner-k3 "bar"}}

user=> (into {}
         (map (juxt (comp :inner-k2 val) identity))
         map-of-maps)
{nil [:k4 {}],
 "correct map" [:k3 {:inner-k1 "foo", :inner-k2 "correct map", :inner-k3 "bar"}],
 "wrong map" [:k5 {:inner-k1 "foo", :inner-k2 "wrong map", :inner-k3 "bar"}]}
user=> (peek (get *1 "correct map"))
{:inner-k1 "foo", :inner-k2 "correct map", :inner-k3 "bar"}

I'm not sure what approach to take. Something about producing an intermediate sequence seemed incorrect because I just need the single inner map with the correct key-value pair, and then will be using some of the values in that map.

Filtering a map does produce a sequence, but it is lazy, so it only computes as much as is needed. Putting something like

(->> (vals m)
     (filter (comp #{"correct map"} :inner-k2))
     first)

so I shouldn't be concerned with the intermediate sequence, and just take more care to recognize when one will be generated

Thanks to both of you for clarifying some of these things for me!

Ideally you don't want to traverse data. Better than searching your data is querying it. But when restructuring like in the second example of @U4ZDX466T is impractical or has too much overhead, yes you shouldn't have to worry about intermediate lazy sequences.

I don't want to be doing this, but I received it from an API in this outlandish format

Then you can consider whether normalizing it in some way up front makes sense for further processing

And that would be like the example above, finding the kv i'm after and then turning that value into a key of a new map?

Creating an index like that would be an example, yes

user> (distinct (map {\1 "a" \2 "a" \3 "b" \4 "b"} "1234"))
("a" "b")

Mapping over the input string like above is a nice way to go about it. A substitution map ch->opt can be built up like

(let [id-list [{:id "b" :option [2 4]} {:id "a" :option [1 3]}]
      ch->opt   (into {}
                      (map (fn [{:keys [id option]}]
                             (zipmap (map #(Character/forDigit % 10) option) (repeat id))))
                      id-list)]
  (distinct (map ch->opt "1234")))

You might also prefer

(let [id-list   [{:id "b" :option [2 4]} {:id "a" :option [1 3]}]
      ch->opt   (into {} (map (fn [{:keys [id option]}] (zipmap option (repeat id)))) id-list)]
  (distinct (map ch->opt (map #(Integer/parseInt %) (str/split "1234" #"")))))

distinct of course not dedupe. i edit mine.

Thanks @UP82LQR9N @U024X3V2YN4 !! you saved me

I did a pretty long live coding demo for London Clojurians a while back https://www.youtube.com/watch?v=gIoadGfm5T8 and their are a few shorter ones on my YouTube channel https://www.youtube.com/c/SeanCorfield_A

I think there's some videos linked from the Practicalli site as well. There are probably quite a few other videos out there from individuals.

I watched the above video and can recommend it! This is one Iquite enjoyed too: https://youtu.be/lU3awBr5C7E

Oh and I think there is a very friendly tutorial like channel that someone recommended recently: “on the code again”

a web notebook style approach: https://nextjournal.com/nextjournal/clojure

The 4Clojure walkthrough videos are examples of thinking through code decisions, most challenges have several approaches to solving the problem https://youtube.com/playlist?list=PLpr9V-R8ZxiDB_KGrbliCsCUrmcBvdW16

Thank you all very much 🙌