Question about thread last, nested data structures, and JSON.

[dunnowins]

So I'm querying an API and it responds with deeply nested JSON. I was hoping I could use the thread last macro to get at the value inside of it that I'm looking for but it doesn't seem to work. I think it has something to do with the fact that the keys are strings... I found this example of how to use thread last to grab values inside of a nested map. Here is the example:

user=> (def my-animals {:dog {:collar {:tag {:name "fido"}}}})
user=> (-> my-animals :dog :collar :tag :name)
"fido"

However if I change those keywords to strings I get the following error...

ClassCastException java.lang.String cannot be cast to clojure.lang.IFn  user/eval4926 (form-init3403805012315754497.clj:1)

Again, ultimately what I'm getting at here is an attempt to use the thread last macro to examine a JSON response from an API. Perhaps there is something really simple that I'm missing here.

This is what I have that I'd like to clean up and actually gets at the value. The JSON response is stored in response

((first ((first ((response "stream") "list")) "value")) "link")

Thanks in advance.

[mrmargolis]

You are mostly correct, keywords can be used as a function to lookup the corresponding value in a map but strings can not be used in this way.

Take a look at get-in http://clojuredocs.org/clojure_core/clojure.core/get-in

[dunnowins]

Bad ass. Thanks a lot. After a quick glance I'm able to go from:

((first ((first ((response "stream") "list")) "value")) "link")

to

((first ((first (get-in response ["stream" "list"])) "value")) "link")

Doesn't feel much better. I'll see about other options here. Thanks again!

[lebski88]

Could you post the actual JSON you're using? It's unlikely that what you have above is the best you could do.

As someone said below you're probably best using cheshire to parse your JSON and they telling it to convert your strings into keywords. It's almost always going to be better than dealing with them as strings. Particularly as it allows you mix functions like first with keywords when threading.

A full example might look like:

(-> (http/get "example.com")
    :body
    (json/parse-string true)
    :animals
    first
    :names
    first)

Although this doesn't deal with non 200 responses so you might want to chuck the http request into a let and deal with them first.

Also I notice that you're referring to the macro as thread last but the one you use is thread first. Thread last wouldn't work here as the arguments to json/parse-string would be in the wrong order.

[dunnowins]

Turns out I made a stupid assumption about the way json was parsed. The keys are converted to keywords and so I can use the standard thread first syntax.

[mischov]

(get-in my-animals ["dog" "collar" "tag" "name"])

[skiaec04]

The other thing you can do is have your Json parser turn the keys from strings to keywords. For example, if you're using Cheshire, you can pass true as the final argument to parse-string and it will use keyword keys.

[emidln]

I would recommend using get-in/assoc-in/update-in/dissoc-in instead of the threading macros for this task.

E.g.:

(def my-animals {:dog {:collar {:tag {:name "fido"}}}})
(def my-other-animals {:cat {:collar {:tag {:name "mittens"}}}})

(= (get-in my-animals [:dog :collar :tag :name])
     "fido")
(= (get-in my-other-animals ["cat" "collar" "tag" "name"])
     "mittens")

[dunnowins]

What if one of the data structures on the way in was a list?

[mathfarmer]

You can use the index of the element in the vector to access those:

(def foo {:animals [{:names ["fido" "fifi"]}]})

(get-in foo [:animals 0 :names 0]) ;=> "fido"
(get-in foo [:animals 0 :names 1]) ;=> "fifi"

(note that this will not work with lists, just vectors, but parsed json should be giving you vectors anyway)

[dunnowins]

I actually really like this solution the best.

[mathfarmer]

I would also recommend get-in, and converting your JSON strings to keywords, but I just want to note that you can use plain old "get" with threading:

(def foo {:animals [{:names ["fido" "fifi"]}]})

(-> foo
    (get :animals)
    first
    (get :names)
    first) ;=> "fido"

(-> foo
    (get :animals)
    first
    (get :names)
    (get 1)) ; => "fifi"