There's not, but you could make one using lazy-cat:

(defn drop-nth [n coll]
  (when-let [s (seq coll)]
    (lazy-cat (take (dec n) (rest s)) (drop-nth n (drop n s)))))

:hugging_face:

Also keep-indexed may be a simpler approach anyway:

(defn drop-nth [n coll]
  (keep-indexed #(when (pos? (rem %1 n)) %2) coll))

:star-struck:

(defn drop-nth [nr] (concat (range nr) (drop (inc nr) (range)))) this is what I would do :)

@U0404ASMSCT unfortunately that just drops n. @U03D1PUDM6W is asking how to drop every nth

oh, that‘s true, I read the question wrong :woman-facepalming::skin-tone-2:

But this may work (defn drop-every-nth [nr coll] (remove (set (range 0 (inc (count coll)) 5)) coll))

(where 5 is replaced with nr) yes, it works, but it's less performant, especially for small nr and large coll:

user> (time (do (doall (drop-every-nth 2 (range 1e7))) nil))
"Elapsed time: 7732.980416 msecs"
nil
user> (time (do (doall (drop-nth 2 (range 1e7))) nil))
"Elapsed time: 4933.956869 msecs"
nil

I would think of it as partitioning and then dropping, maybe something like

(->> (range 30)
       (partition-all 5)
       (mapcat rest))

(into [] (comp (partition-all 5) (mapcat rest)) (range 30)) ;; => [1 2 3 4 6 7 8 9 11 12 13 14 16 17 18 19 21 22 23 24 26 27 28 29]

https://http-kit.github.io/

Thanks, does it have support for retries?

isn't that very easy to do via loop or something

if you want something much more sophisticated there are libs like https://github.com/xsc/claro

http-kit says it's based on clj-http, which has retries. so i'm guessing that kit probably has that too

Where does it say that?

Ah OK

I think clj-http just has retries as it’s based on the Apache HTTP client

kit doesn’t seem to mention retries

you have to look in it's code to be sure. may also want to look at how clj-http does it, cus if it's just a line of code or something you may be putting too much value on that feature

There doesn’t seem to be anything in the kit code for it I can see

I like https://github.com/sunng87/diehard for retries (of any kind).

that's a lot better, now you have the same retry interface for different things in your app

True, though HTTP requests will be the only thing in this case

Are there any reasons in particular to go with kit over clj-http? Lack of dependencies in the former perhaps but that’s not much of a concern

I certainly like the idea of retries out of the box without having to think about it

I tend to go for clj-http, if only because clj-http-lite often doesn't have features that I want (like proxy support)

Haven't used http-kit, though

http-kit has a focus on concurrent features, probably could be implemented with core.async or manifold without much effort

juxt?

reduce

or even just comp

(map (apply comp funs) coll)

looks like comp from the code example

(reduce #(map %2 %) coll funs)

Stylistically, is one solution more readable than the other?

(sequence (apply comp (reverse (map map funs))) coll)

the first comp example is going to be more efficient

don't you need a reverse in there?

(map (apply comp (reverse funcs)) coll)

oh, maybe, could be I switched the reverse in the first comp and the sequence examples

yep

user=> ((comp inc (partial * 2)) 0)
1
user=>

user=> (sequence (comp (map inc) (map (partial * 2))) [0])
(2)
user=>

let takes a literal vector - it's a special form that expects that as part of its syntax, so this is not possible regardless. but what are you really wanting to do?

you can do a nested let

Well - I have a set of configuration variables such as:

(def company_auth_params {
                           :dev {:code-challenge "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                                 :code_verifier "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                                 :client_id "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                                 :auth-header "Basic XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                                 :redirect_uri ""
                                 :login_uri ""
                                 :authorize_uri ""
                                 :token_uri ""}
                           })

and in my function, I have a let and that let has its own bindings. I though it would be nice to just “combine” the pre-defined params into that let binding so that I could refer to them directly.

you can destructure to get that

oooooh

(let [ [:code-challenge :code-verifier] (company_auth_params :dev) more stuf…]

(let [{:keys [code-challenge verifier client_id]} (:dev company_auth_params)]
  ...)

aha! Even better, thank you sir this is super helpful. Trying now.

That worked awesome, thanks @U064X3EF3 👍

happy Clojureing!

It has been happy Clojureing indeed 🙂

btw you can learn more about destructuring in the guide https://clojure.org/guides/destructuring