Clojurians Log v2

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: https://youtu.be/Qx0-pViyIDU?t=1463

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,..

Liked the episode by the way. I also found out about Clojure Koans early on, which I liked, and this year I plan to do Advent of Code in Clojure. Regarding all the goodness in clojure.core, I’ve been wondering whether I should spend time to sit down and go through the whole thing, function by function, on clojuredocs for example. On the one hand I’m sure I would learn lots of valuable things, on the other hand I’m a bit wary of the amount of time and effort it would require 🙂

I think not necessarily right from the start.

Agreed! But when then? 🙂

Of course is useful to learn the most used functions - for this books like Programming Clojure + exercises like 4clojure might be useful

Probably similar to the "spend at least a year" advice but it really depends

Whenever you find a strong desire to do so 🙂

For that I'd consider https://www.manning.com/books/clojure-the-essential-reference + reading the clojure.core source code

Yeah I guess that’s as good an answer as can be expected 🙂

Ah that seems like an interesting book!

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?

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)

(sort-by #(get-in % [:player :name]) players)

(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.