(filter #(= ["dev" "python-test-env"] ((juxt :stackName :projectName) %)))

Wow, nice! Thanks. Here's a working code sample in case anyone else finds it useful:

(let [data (list {:orgName "my-org"
                  :projectName "my-project"
                  :stackName "stack-1"
                  :lastUpdate 1695305272
                  :resourceCount 14}
                 {:orgName "my-org"
                  :projectName "python-test-env"
                  :stackName "dev"
                  :lastUpdate 1695106891
                  :resourceCount 16}
                 {:orgName "my-org"
                  :projectName "my-project"
                  :stackName "stack-3"
                  :lastUpdate 1698324490
                  :resourceCount 16})]
  (->> data
       (filter #(= ["dev" "python-test-env"]
                   ((juxt :stackName :projectName) %)))))

Although I have no idea how juxt works 😅

however, your snippet should work just fine. My example does not do anything different

Just a nice way to say that ((juxt a b c) x) => [(a x) (b x) (c x)]

Ah, wow! Yes, it does work with my test data! But not with the data returned from the API I'm using. Weird.

Maybe I don't have a list of maps after all, from the API I'm consuming. Hmmm.

maybe keys a not keywords? some clients doesn't translate keys automaticaly from strings

I'm converting it to keywords like so:

(defn response-body->json [response]
  (-> (:body response)
      (json/parse-string keyword)))

(defn make-request [request]
  (-> request
      (http-kit/request response-body->json)
      deref))

(defn fetch-page [request & [token]]
  (-> request
      (cond-> token (assoc-in [:query-params :continuationToken] token))
      make-request))

(defn fetch-all-pages [request val-fn key-fn]
  (-> (iteration (partial fetch-page request)
                 :vf val-fn
                 :kf key-fn)
      seq
      flatten))

and parse-string is from cheshire?

Yeah!

And here is my whole ->> thread:

(doall
   (->> (fetch-all-pages stack-request :stacks :continuationToken)
        (filter #(and (= "python-test-env" (:projectName %))
                      (= "dev" (:stackName %))))
        (create-permission-request "PULUMI_ALL_STACKS_READ" :read)
        make-request))

(doall
   (->> (fetch-all-pages stack-request :stacks :continuationToken)
        (filter #(and (= "python-test-env" (:projectName %))
                      (= "dev" (:stackName %))))
        (create-permission-request "PULUMI_ALL_STACKS_READ" :read)
        make-request))

Ah, sorry, that was actually a copy-paste error from when I tried your juxt solution and reverted back to mine. I edited my thread above again now.

I found out that (fetch-all-pages stack-request :stacks :continuationToken) returns a clojure.lang.LazySeq (not a list of maps) which is passed on to filter.

that is fine. filter can filter lazy seqs

I would start step by step debugging but usually this depends on IDE support. another way could be this:

(filter (fn [x]
          (prn "---DBG" x)
          (= ["dev" "python-test-env"] ((juxt :stackName :projectName) x))))

just print every item that is passed to the filter to see unexpected data structure

Awesome, thanks for the help!

Oh my Lord, I'm such a dumbass. python-test-repo was the actual project name. I just filtered for the wrong string 😅:man-facepalming:

And my code was correct, haha! Sorry for wasting your time, @U04V4KLKC

Although that debug trick of yours did help me realize my mistake!

no worries, glad to help)

https://clojurians.slack.com/archives/C02B5GHQWP4/p1679593727188979?thread_ts=1679593727.188979&cid=C02B5GHQWP4

I searched Slack for exclude license

Thank you!

it looks like the watches are added to a map, and add-watch calls assoc , so the old watch is replaced

hm. so if you are creating watches programmatically, what should you do about a key? just grab something from your context that would be unique?

sure - gensyms are also an option

(Object.)

thanks guys

The sort of glib answer is that a vector doesn't implement ISeq. If the desired is a function that can identify if its argument can be converted to a sequence with the seq function, that's seqable?

vectors are not seqs, but can provide a seq view

seq functions seq their argument to obtain the view

Thank you. This raises more questions but I will try to divine the answers myself first.