Ep 018: Did I Work Late on Tuesday?

Functional Design in Clojure

Christoph wants to teach filter some vocabulary.

• Continuing our discussion of rummaging through the big bag of data.
• Mental shift for solving the problem:
  • Prior thinking: one function that has to look at all entries
  • New thinking: filter out irrelevant entries then reduce on just those
• New mentality emphasizes the problem of "picking" over "combining". Once you have the right set of entries, the reduce becomes trivial.
• Idea: build up a "vocabulary" of picking.
• "You build up the language to the level you want to use it at."
• A "predicate" is simply a function that gives you a truth value.
• We want to create a set of predicates to use with filter.
• By convention, predicates in Clojure end with ?. Eg. some?, contains?, every?
• First predicate to create: (spans-midnight? start-timestamp end-timestamp)
• Problem: using it is verbose: (filter #(spans-midnight? (:start %) (:end %)) entries)
• Better idea: have the predicate take an entry.
• The predicate should speak at the level of the items for filter.
  • Just take entry: (spans-midnight? entry)
  • Usage: (filter spans-midnight? entries)
• New question: how many minutes did I work on the weekend?
  • New predicate: (weekend? entry)
  • Usage: (filter weekend? entries)
• "My time in Clojure makes me look at big, long functions and wonder if they should be broken into smaller pieces."
• Simplify implementation of weekend? with a simpler predicate: (day-of-week? weekday entry)
• Order matters: put weekday first for partial.
• Now the weekend? function is a simple or of calls to day-of-week?
• Even better: use an "extractor" function (day-of-week entry) that returns the day.
• Useful for day-of-week? but also for any other logic that needs to pull out the day.
• An "extractor" provides a useful view of the data.
• Now a weekday? predicate becomes trivial: (not (weekend? entry))
• Key idea: the use of language mirrors how we talk about it.
• Not just about decomposition, but about how it reads linguistically.
• Can make a predicate for any day of the week with: (partial day-of-week? :sunday), etc.
• Use like so: (filter (partial day-of-week? :sunday) entries)
• "Partial to parameterize a predicate." (Say that three times fast.)
• New question: did I work a long day on Tuesday?
  • Won't work to write a predicate at the "entry" level
  • Need a new "day" level
• Once again, the language hints at the level of abstraction.
• Idea: function that "uplevels" by taking a list of entries and producing a list of days
• Predicates can work at both levels if entry and day have some consistent structure.
• The "structure" (or "data shape") is a consistent use of keys and key paths between abstractions. It is not a "base class".
• Eg.: both entry and day have a :date key, so the same day-of-week? predicate works on both.

Related episodes:

• 015: Finding the Time
• 016: When 8 - 1 = 6
• 017: Data, at Your Service

Clojure in this episode:

• filter
• reduce
• partial
• or

Code sample from this episode:

(ns time.week-04  (:require  [time.week-03 :as week-03]  [java-time :as jt]))   ; Helper for loading up time entries  (defn log-times  [filename]  (->> (week-03/lines filename)  (week-03/times)))   ; Extractors  (defn day-of-week  [entry]  (jt/day-of-week (-> entry :date)))   ; Predicates  (defn spans-midnight?  [entry]  (not= (jt/local-date (:start entry)) (jt/local-date (:end entry))))  (defn day-of-week?  [day entry]  (= (day-of-week entry) (jt/day-of-week day)))  (defn weekend?  [entry]  (or (day-of-week? :saturday entry)  (day-of-week? :sunday entry)))  (defn weekday?  [entry]  (not (weekend? entry)))   ; Aggregations  (defn total-minutes  [entries]  (->> entries  (map :minutes)  (reduce +)))   (comment  (->> (log-times "time-log.txt")  (filter spans-midnight?))  (->> (log-times "time-log.txt")  (filter (partial day-of-week? :wednesday)))  (->> (log-times "time-log.txt")  (filter weekend?))  (->> (log-times "time-log.txt")  (filter weekday?)  (total-minutes))  )