Clojure Q&A - Recent questions tagged into

Use transducer arity of `into` in `clojure.walk` namespace

Wed, 13 Sep 2023 22:49:05 +0000

It's simple. Just like that:

> clojure.walk/walk:
(outer (reduce (fn [r x] (conj r (inner x))) form form))
=> (outer (into form (map inner) form))
(outer (into (empty form) (map inner form)))
=> (outer (into (empty form) (map inner) form))

> clojure.walk/keywordize-keys:
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)
=> (postwalk (fn [x] (if (map? x) (into {} (map f) x) x)) m)

> clojure.walk/strigify-keys:
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)
=> (postwalk (fn [x] (if (map? x) (into {} (map f) x) x)) m)

Is there any performance difference between creating vector via (into [] xs) or (vec xs)?

Sat, 03 Jun 2023 11:35:12 +0000

I can create set/map/vector by two ways:

(into #{} xs) ;; creates PersistentHashSet
(set xs)      ;; creates PersistentHashSet

(into {} xs)  ;; creates PersistentArrayMap or PersistentHashMap (depends on xs size) 
(apply hash-map xs) ;; creates PersistentHashMap

(into [] xs)  ;; creates PersistentVector
(vec xs)      ;; creates PersistentVector

(into r xs):
- defines generic algorithm by conj!-ing input sequence 1 by 1 to passed result collection (uses transient/persistent trick)

(ctor xs):
- defines precisely type of result data structure
- passes xs sequence as an argument to constructor (which is static java function) so every ctor may define its own logic of creation (maybe by not conj-ing input sequence 1 by 1)

Are there any performance differences between these two ways?
Maybe there is an established idiom what to use when?

Thanks!

Cast to Map$Entry Exception When Trying to (Into {}) After Sequence Operations

Sun, 08 May 2022 09:17:12 +0000

Is it intended behavior to get this exception :

class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

on this piece of code :

(def a [["Active" :Transit-RLC "Active"]])

(->> a
     (transduce
       (comp 
             (map drop-last)
             (map reverse))
       conj [])
     (into {}))

changing the transducer to (map (-> [(second %) (first %)]) solves the issue.
Thanks