That's what I have seen used in many places

(reduce-kv
 (fn [acc par deps]
   (reduce #(update %1 %2 (fnil conj #{}) par) acc deps))
 {}
 graph)

(fixed a typo)

This looks a lot cleaner 🙂. Thanks @U04HK53G7SQ

No worries!

Because the maps are not identical objects in memory. Check out https://clojuredocs.org/clojure.core/identical_q and read the comments, especially the last one about being careful about using the function at all

It's JVM semantics, you can come up with much simpler cases, like (identical? 0.0 .0.0) => false

It's best considered a useless function

Oh ok Thanks you

when you have to add metadata to some dynamically created object that supports metadata.

user=> (meta (let [x [1 2 3]] ^:foo x))
nil
user=> (meta (let [x [1 2 3]] (with-meta x {:foo true})))
{:foo true}

Why do we have to add metadata ?

I meant, which scenario we add it? is there any drawback if we do not add it ?

there are few cases when it can be usefull here is one for example https://clojure.org/reference/protocols#_extend_via_metadata

by adding metadata you can implement a protocol implicitly

Will take a look

Metadata is also useful for cases where you want to be able to compare data using = while attaching certain metadata to the data, e.g. :source . The data stays equivalent, but you get to keep track of where it came from.

This returns true, for example:

(= (with-meta {:a 1} {:source "$some_user"})
   (with-meta {:a 1} {:source "$some_other_user"}))

I'm not sure if it's a typo or part of your problem, but you're not passing a function to filter, you're passing the boolean result of calling a function

vs. say (filter (fn [{title :title}] (str/includes? title "quick")) data)

Yes, sorry it's become peudo code at this point after a few goes around,🙃

If you care about the result being a vector and not a lazy seq, you could call

(let [foo [{:title "the quick brown fox"
            :data  "data"
            :more  "data"}
           {:title "the slow brown fox"
            :data  "data2"
            :more  "data2"}]]
  (filterv #(str/includes? (:title %) "quick") foo))

that code is testing the maps for string inclusion

Edited. I’d elided the extraction of the :title.

@U2EJEK2SX if you want to paste a gist or something I can try to help

A way to think about this so you can get yourself unstuck in the future. When you want to do something to a collection, write a function that works on a single one. And only once that function is working on a single one then use it with filter and the rest of the functions

Thanks everyone, I got into the weeds with trying to parse every map etc

Meta-tip: I know well the temptation, but I try never to post anything other than actual code. People are going to spend time on analyzing and even running it, I figure, so it has to be real. No harm I guess in loudly announcing the code is just pseudo-code up front. hth!

Sorry! I'll keep that in mind in the future

Demonstration of @U11BV7MTK’s suggestion. Break it down to extremely easy problems, and build back up to the target.

Thanks @U90R0EPHA that's a really helpful example

This works, but I'm thinking there must be a nicer way

(into {} (for [[k v] c
                 :when (>= k a)]
             [k (if (= k a)
                  (remove (fn [x] (< x b)) v) v)]))

Have you considered using a https://clojuredocs.org/clojure.core/sorted-map

I hadn't! Would that make removing keys less than n simpler ?

`(subseq (into (sorted-map) {1 [1 2 3 4 5] 2 [1 2 3 4 5] 3 [6 7 8 9 10] 4 [1 4 5 6 7]}) < n)`

nice, i didnt' know about subseq either

❯ clj -Sdeps '{:deps {org.clojure/data.avl {:mvn/version "0.1.0"}}}'
Downloading: org/clojure/data.avl/0.1.0/data.avl-0.1.0.pom from central
Downloading: org/clojure/data.avl/0.1.0/data.avl-0.1.0.jar from central
Clojure 1.11.1
user=> (require '[clojure.data.avl :as avl])
nil
user=>   (let [c (avl/sorted-map
            1 [1 2 3 4 5]
            2 [1 2 3 4 5]
            3 [6 7 8 9 10]
            4 [1 4 5 6 7])
        a 3
        b 7]
    (avl/subrange c >= a <= b))
{3 [6 7 8 9 10], 4 [1 4 5 6 7]}
user=>

Is their any specific reason why I was getting the error n.replace is not a function with my code ? I'm finding clojure(script) errors pretty tricky to deal with and find the actual problem

for the rest i'd go w/ something like (as-> thing m (into (sorted-map) m) (update m a (partial filter (partial >= b)) (subseq m < n) (into {} m)) or whatever

avl trees offer a non-linear way to accomplish this. just wanted to highlight that. ie no filter on the keys yourself

I'll check it out, wasn't aware of that library

on the error, you're trying to destructure members of (c a) into [_ v], but it's a flat vector

oh yeah! I was confused thinking I was still dealing with key value pairs at that point.

obviously the error message is of no help

I don’t think it’s great, but an option is reduce-kv with a cond in the body

(doc reduce)

"If coll has only 1 item, it is returned and f is not called."

yes, thank you!