Fork me on GitHub

why not just use nested maps if that's how the data needs to be accessed?


also I wonder if meander would be good for this use case


I guess that's the usual approach but Chris and Nate have been advocating namespaced maps I believe 🙂


nesting maps is definitely a common approach


we've found that flattening maps leads to simpler code: fewer calls to get-in to dive into deeply nested data structures


of course, nesting is still used for sub-entities


for an example of what namespacing can do, look at Stuart Halloway's example here:


you could structure that data as nested maps, but using rich keys makes it unnecessary


I just mean that if you need to access all the keys with a given prefix then that probably means you're better off nesting maps


barring other constraints


oh, I see what you mean


yeah, unmixing data is much easier with nested maps


but yeah, medley has a filter-kv that might do the trick for filtering on the key namespace. unfortunately that also means iterating over the entire map, though :(


oh, it has filter-keys too


I'll have to try it out.


Hi guys, I just listened to your episode #37 about, well, me basically 🙂 One piece of advice I would give other beginners is to choose an IDE and stick with it for a while. Like, minimum a year or so. In this stage of your learning it really doesn’t matter which one, all of them are good enough. Just use what you’re familiar with. I find I’m constantly tempted to try other thing because of stuff I hear experts say, and before you know it your learning editors and plugins instead of Clojure,..


@UGNFXV1FA I think that's great advice! Thanks! I totally relate to wandering off on "expert picks". Make progress first. Optimize later. 🙂


Hi. Just a small correction to the nil punning episode (sorry if mentioned before): Ruby just like Clojure only evaluates nil and false to false, everything else is truthy. Maybe you meant to say PHP at 14:00?


@U3UDMF5ME Did we say that about Ruby? Good catch. We've both worked with Perl the most, and I think we might assign some of Perl's attributes to Ruby sometimes. 😁

😄 1

I missed all the fun discussion about rich keys. We'll have to talk about that on the podcast. My short opinion is that they involve a lot less ceremony than nested maps, so your code gets simpler. For example, suppose you want to sort by player/name. That's:

(sort-by :player/name players)
instead of
(sort-by #(get-in % [:player :name]) players)
or even
(sort-by #(-> % :player :name) players)


And then, of course, the ceremony just multiplies if you want to sort by name and then ID.


(sort-by (juxt #(-> % :player :name) #(-> % :player :id)) players)
(sort-by (juxt :player/name :player/id) players)


At least for what Nate and I work on, it's useful to think of a map as a bag of dimensions that can grow or shrink. We have data pipelines, so we may start with a map that just has IDs in it, but then we enrich it with other data.


Likewise, we may have a map with lots of rich information in it (because it's not normalized), and we'll want to pick out all the ID parts for persistence and not save the rich information that got woven in from somewhere else.


Suppose I want to cut down the map to just :player/name, :player/id, and :team/name. So easy with rich keys:

(select-keys player [:player/name :player/id :team/id])


But with nested maps. If want to preserve the same structure. Once again, more ceremony.

(let [{{team-id :id} :team
       {player-id :id, player-name :name} :player} player]
  {:team {:id team-id}
   :player {:id player-id
            :name player-name}})


Or maybe

{:team (select-keys (:team player) [:id])
 :player (select-keys (:player player) [:id :name])}


I prefer the rich keys.