you may have the arguments in the wrong order. into should work:

user> (type {:a 1})
clojure.lang.PersistentArrayMap
user> (into [] {:a 1})
[[:a 1]]

My data is: [{:a :b} {:c :d}], so I want to convert to [[:a :b] [:c :d]]. And I write code like this:

(mapv (into []) data)

Any wrong in there?

that seems like an odd transformation. I might try something like:

user> (->> [{:a :b} {:c :d}]
           (mapcat vec)
           (into []))
[[:a :b] [:c :d]]

it's common for programmers that come to clojure, especially from statically typed languages, to overemphasize the underlying concrete data type. You may only need:

user> (into [] cat [{:a :b} {:c :d}])
[[:a :b] [:c :d]]

Yeah, That's a bit odd indeed, because the logic of this is for handle data from Java, so in Java, I have defined some concrete type to describe data which like you said. I reference your answer write code shows below. And thank you for your help.

->> records (mapv vec) (into [])

I have another question , How recur with ->>?

->> is only a syntax transform, it's not an operator or function of any sort

you need a function or loop to recur

(I mean strictly speaking it's a function that runs at compile time and transforms the form before it's compiled, but it's not the kind of function that creates a binding that can recur)

All right, Thank you.

I’ve used this to lowercase string-keys (assuming you convert from json to maps beforehand) for a single layer one before but I’m sure there’s a better way:

(into {} (map #([[k v] [(str/lower-case k) v]) input))

(defn deep-lowercase-map [m]
  (reduce
   (fn [acc [k v]]
     (if (map? v)
       (merge acc (lowercase-map k (deep-lowercase-map v)))
       (assoc acc k v)))
   {}
   m)) 

(javahippie seems to have done a postwalk version, probably better to refer to that)

Instead of using reduce on a hash map, consider reduce-kv

reduce is going to call seq on the hash map and turn it into a sequence of pairs (`MapEntry` pairs which are like vectors) and you have to destructure the key/value pair -- as you have with [k v] -- reduce-kv operates directly on the hash map and invokes the reducing function with three arguments: (fn [acc k v] ..) -- no destructuring needed.

Ohhh that’s actually awesome! another gold nugget for my collection, Thanks Sean

(into {} (map f x)) can become (into {} (map f) x)

peak the one you most familiar with and then look for the client in clojure or java (unlikely you will not be able to find one)

OK, I guess I’m most familiar with regular ol’ SQL.

This sounds like a job for redis honestly

If you're comfortable with redis that is.

@UH0FTE610 go with SQL, I recommend https://github.com/seancorfield/next-jdbc

Also https://github.com/seancorfield/honeysql

And if you get stuck with either of those, ask in #sql and/or #honeysql as appropriate. They're lower traffic than #beginners and it's more likely someone will give you a good answer quickly. Probably me 😉

I appreciate all the replies. Thanks!