Find definition of what?

some function definition, local or from the library both.

I called lsp-find-definition

What does the squiggle on line 28 say?

can you should the output of clj-kondo --lint script.clj?

I see, it comes from lsp, not from kondo, kondo reports only unused requires (but flycheck don't), that's the err on line 28: 1 1 error syntax Can't parse /Users/flawless/projects/tools/convert_binance.bb, No matching clause: :unknown (lsp)

cc @UKFSJSM38

That sounds like a outdated clojure-lsp, could you share/check lsp-clojure-server-info?

I updated clojure-lsp and the problem has gone. Actually I just had clojure lsp installed from incorrect tap. Thank you all.

yeah, I'd love to remove the outdated clojure-lsp from the core brew but they don't want it :)

(doseq [x @selections] (println x))

if you mean where the :id is in the selections set, then this should work

(filter (comp @selections :id) @multi-select-items)

selections doesn't have :id in it, just a hash-set of numbers

I mean the :id in the mulit-select-items atom. So for your example, I assume the result you want is a seq with only the first map in {:value A :id 27069}

Yes

so filter takes a predicate and a sequence and returns a sequence containing only the elements where the predicate returns true. The predicate here is built by combining 2 functions with comp . The first function that comp will call is :id which will get the :id key from each map and pass it to the set in the selections atom which will look that value up in the set. If it's not there, it will return nil which is considered falsey by filter and the resulting seq will not include that value. Does that make sense?

Yeah I understand, it returns nil now since selections has no :id, if i has :id, which I tried, it returns what I want. So, what can I do?

(let [multi-select-items (atom '({:value A :id 27069} {:value B :id 27070}))  
        selections         (atom #{2 4 6 27069})]
    (filter (comp @selections :id) @multi-select-items)) ;; => ({:value A, :id 27069})

YES! Thanks alot 🙏

Hi, how can I only return :value in the filter?

once you've filtered the list, you need to then map a transformation over that list. Maybe something like

(let [multi-select-items (atom '({:value A :id 27069} {:value B :id 27070}))  
        selections         (atom #{2 4 6 27069})]
    (->> (filter (comp @selections :id) @multi-select-items)
         (map :value))) ;; (A)

Great! thanks

(let [{{:keys [db]} :context} {:context {:db "xxx"}}]
  db)

sometimes :keys can confuse you about how destructuring works. It is a bit of sugar. This might make it clearer how you can just use destructuring recursively

(let [{{thing :db} :context} {:context {:db "xxx"}}]
  thing)

Thanks @U11BV7MTK, the :keys destructuring does make sense.

@U11BV7MTK On second thought it is confusing.

{:keys [foo bar]} is equivalent to destructuring {foo :foo bar :bar}

the keyword you destructure at is bound to a local of the same name. but in general the pattern is {local :key}. And this can nest. {{thing :db} :context} as above, or {{:keys [db]} :context}

Yes, understood. I'm trying to think how keys destructuring might (Does it?) work with multiple keys instead of a single one at top level. Named destructuring makes more sense there I guess.

what do you mean multiple keys? Give a structure you’d like to destructure

{:context {:year "2022" :user "dr"} :data {:plant "apple :birth "2019"}} Suppose I want to get year and plant and birth inside a let ?

tcp=> (let [structure {:context {:year "2022" :user "dr"} :data {:plant "apple" :birth "2019"}}
            {{:keys [year]} :context {birth-local :birth} :data} structure]
        [birth-local year])
["2019" "2022"]

(let [{{year :year} :context {:keys [plant birth]} :data} m] ...)

there is no top level. it’s just destructuring at “this” level

tcp=> (let [{foo :foo} {:foo "top level is just where you are"}]
        foo)
"top level is just where you are"

and note we’ve been destructuring :context at the top level this whole time

You can also interweave sequence destructuring.

(let [m {:foo [{:bar :baz} {:fiz :buz}]}
      {[_ {fiz :fiz} :as ms] :foo} m]
  {:fiz fiz
   :ms ms})
; =>
;; {:fiz :buz,
;;  :ms [{:bar :baz} {:fiz :buz}]}

> keys destructuring might (Does it?) work with multiple keys instead of a single one at top level Are you trying indicate the :keys sugar here? I don't think that offers facilities for descent into nested maps. Just use the unsugared version.