does anyone know how to create user-defined tag literals in clojurescript?

Is there a function that does (first (filter ...))effectively on a chunked seq?

I found three ways on stackoverflow, they are (first (drop-while ...)), reduce with reduced and some with a #(when (pred %) %), I wonder if there's a better way?

There's also (first (eduction (filter pred) (take 1) coll))

I benchmarked the different ways of doing this:

(def coll (seq (into [] (range 10000))))
(def pred #(< 1000 %))

(defn filter+first [] (first (filter pred coll)))
(defn some+when [] (some #(when (pred %) %) coll))
(defn eduction+first [] (first (eduction (filter pred) (take 1) coll)))
(defn reduce+reduced [] (reduce #(when (pred %2) (reduced %2)) nil coll))

{:filter   "12.65µs"
 :some     "22.15µs"
 :eduction "21.16µs"
 :reduce   "7.14µs"}

Benchmarked using criterium {:mvn/version "0.4.4"} with (criterium.core/bench (f))

I'm quite surprised that this works 🙂

(random.namespace.which.does.not.exist/.split "ahoj" "ah")
;;=> ["", "oj"]

Can anyone point me to some documentation regarding the behavior of the leinigen project.clj flag :exclusions. I'm encountering a gordian knot of dependency conflicts between ring and datomic cloud and in the process of trying to fix it have realized I only vaguely understand what actually is being "excluded".

This is the writeup of the problem I've hit (my initial "solution" turned out not to be one): https://stackoverflow.com/questions/50331264/ssl-doesnt-have-a-valid-keystore-error-when-trying-to-connect-to-datomic-clou

@petterik great work! which should I choice if the pred function is heavy. use reduce + reduced?

@doglooksgood the pred function will be run the same amount of times for all examples, so it shouldn't matter. I'd choose filter+first or some+when when performance doesn't matter because it's easier to understand. The reduce+reduced when perf matters

great!

say I have a collection of 3-tuples, what's a good way to map over that and apply a different function to each tuple element?

(map (fn [f x] (f x)) [f1 f2 f3] tuple) ?

mapv is probably a better choice

yah, just trying out a few options for mapping that over a collection

ah, a collection of tuples?

[[:a :b :c] [:d :e :f]]

let's say we want to map [str name keyword?] over that

(->> [[:a :b :c] [:d :e :f]]
       (map (partial interleave [str name keyword?]))
       (map (partial partition 2)))

halfway there ....

but then it's hard to map apply across because the fn and args are in one collection, end up having to map (apply (first %) (rest %))

I'm shaving this yak pretty hard ;)

(for [[a b c] tuples]
        [(str a) (name b) (keyword? c)])

it's a bit harder to parametrize this snippet by functions as well, but i think it's the easiest to understand

I do in fact want to parameterize the fn list

or did they want (for [[a b c] tuples f [str name keyword]] [(f a) (f b) (f c)])

the fn I'm ultimately writing will look like: (clean-collection [fn1 fn2 fn3] some-coll), where some-coll is a collection of 3-tuples (in this case)

and what does the result look like?

does fn1 only get called on the first item of some-coll, all of them?

it's positional, so [[:a :b :c] [:d :e :f]] will end up like [[(fn1 :a) (fn2 :b) (fn3 :c)] [(fn1 :d) (fn2 :e) (fn3 :f)]]

oh (map #(%1 %2) fns coll)

oh, for each coll

(for [coll colls] (map #(%1 %2) fns coll))

i like that one

there's a dirty trick where deliver is equivalent to #(%1 %2) but don't use that, it's an implementation detail of promise

ohh, the #(%1 %2) idiom, that's the kind of thing I was missing … I remember that from stuff like

(condp #(%1 %2) "thing"
    keyword? "keyword!"
    string? "string!")

(for [coll [[:a :b :c] [:d :e :f]]]
    (map #(%1 %2) [str name keyword?] coll))
=> ((":a" "b" true) (":d" "e" true))

looks nice

(mapv (partial mapv #(%1 %2) [str name keyword?]) [[:a :b :c] [:d :e :f]])

\o/

thanks for bouncing that one around :)

I think map inside for is nicer than mapv partial mapv