Корень композиции

;; Composition root folds into one function that builds
;; the adapters and hands them to the use case: no
;; container, only arguments

;; Entity
(defn payable [order]
  (let [total (:total order)]
    (if (>= total 200)
      (- total (quot total 10))
      total)))

;; Gateway
(defprotocol Catalog
  (price [catalog sku]))

;; Repository: it numbers what it saves
(defprotocol Orders
  (save [orders order])
  (saved [orders]))

;; Output port
(defprotocol Report
  (say [report text]))

;; Use case: asks for its parts, never builds them
(defn place-order [catalog orders report]
  (fn [items]
    (if-let [sku (first (remove #(price catalog %)
                                (keys items)))]
      (say report (str "no " sku))
      (let [total (reduce + 0
                          (for [[sku qty] items]
                            (* (price catalog sku) qty)))
            order (save orders {:total total})]
        (say report (str "order " (:id order)
                         " for " (payable order)))))))

;; Adapters
(defrecord MemoryCatalog [prices]
  Catalog
  (price [_ sku]
    (get prices sku)))

(defrecord MemoryOrders [rows]
  Orders
  (save [_ order]
    (peek (swap! rows
                 (fn [kept]
                   (conj kept
                         (assoc order :id
                                (+ 1001 (count kept))))))))
  (saved [_]
    (count @rows)))

(def console-report
  (reify Report
    (say [_ text]
      (println text))))

(def silent-report
  (reify Report
    (say [_ _])))

;; Composition root: the only place that sees every
;; layer at once, and the only place that names an
;; adapter. The app it returns is a plain map
(defn shop-app [report]
  (let [orders (->MemoryOrders (atom []))]
    {:place (place-order
              (->MemoryCatalog {"pen" 30 "lamp" 190})
              orders
              report)
     :orders orders}))

(defn loud [] (shop-app console-report))
(defn quiet [] (shop-app silent-report))

;; Client code
(def app (loud))
((:place app) {"pen" 2 "lamp" 1})
((:place app) {"chair" 1})

;; A second root builds the same use case differently
(def night (quiet))
((:place night) {"lamp" 1})
(println "saved" (saved (:orders night)))
;; printed: order 1001 for 225
;;          no chair
;;          saved 1