Does Clojure have an efficient, idiomatic approach for decorators?

Question

In Clojure(script) you define programming constructs with deftype and defrecord. We want our constructs to each have a specific, well-defined purpose. Rather than evolve any one construct into a monolithic full-featured thing, we choose to segregate responsibilities. Decorators (e.g. data structures that wrap other data structures) are good for this.

For example, you have a logger construct. You add timestamping as a feature with a decorator. You later add alerting support staff beepers as another decorator. We can, in theory, layer on any number of features this way. Our config file cleanly determines which features get included.

If our logger implements a 3-method Logging protocol and each decorator only augments one, you still have to implement the other two methods on each decorator to uphold the contractual api. These add-nothing implementations simply pass the message down the chain. This is the awkward bit.

The richer a construct's api, the worse the problem. Consider a construct that implements a few protocols and the work necessary to decorate something that handles 12 or so methods.

Is there a mechanism, macro, or technique that you've found to overcomes this?

One technique used to wrap data structures with other data structures, or indeed functions with other functions is called 'middleware'. Typically people come across it with Ring: github.com/ring-clojure/ring/wiki/Concepts. — Chris Murphy
Middleware is great but from my experience it's designed for functions (e.g. contracts that deal with just 1 kind of message). When you have a construct with potentially several methods (e.g. a protocol), is where the complication I mention comes about. The question is: how to build middleware for constructs that support multiple methods without having to flesh out every method at every layer? — Mario
Middleware is exactly the decorator pattern, applied to functions. This question is about how to apply it to a "bundle" of multiple functions. — amalloy

Beyamor Beyamor · Accepted Answer · 2017-07-06T16:22:31

One option is to use extend to merge a mix of delegating-by-default functions and overriding implementations.

For example, with a logger protocol like:

(defprotocol Logger
  (info [logger s])
  (warn [logger s])
  (debug [logger s]))

(def println-logger
  (reify Logger
    (info [_ s]
      (println "Info:" s))
    (warn [_ s]
      (println "Warn:" s))
    (debug [_ s]
      (println "Debug:" s))))

You could write a function that creates decorator implementations like so:

(defn decorate-fn
  "Creates a decorator function
   given the implementation accessor and the called function."
  [impl f]
  (fn [decorator & args]
    (apply f (impl decorator) args)))

(defn gen-decorators
  "Creates a map of decorator functions."
  [impl fs]
  (into {} (for [[k f] fs]
             [k (decorate-fn impl f)])))

(defn decorate-logger
  "Creates a logger decorator with functions
   passing through to the implementation by default."
  [impl overrides]
  (merge (gen-decorators impl
                         {:info info
                          :warn warn
                          :debug debug})
         overrides))

And then use that to easily create decorators:

(defrecord CapslockWarningLogger [impl])

(extend CapslockWarningLogger
  Logger
  (decorate-logger :impl
                   {:warn (fn [{:keys [impl]} s]
                            (warn impl (clojure.string/upper-case s)))}))

(defrecord SelectiveDebugLogger [ignored impl])

(extend SelectiveDebugLogger
  Logger
  (decorate-logger :impl
                   {:debug (fn [{:keys [impl ignored]} s]
                             (when-not (ignored s)
                               (debug impl s)))}))

(def logger
  (->SelectiveDebugLogger #{"ignored"}
                          (->CapslockWarningLogger
                            println-logger)))

(info logger "something")
; Info: something
; => nil

(warn logger "something else")
; Warn: SOMETHING ELSE
; => nil

(debug logger "ignored")
; => nil

Does Clojure have an efficient, idiomatic approach for decorators?

2 Answers