🔧 Clojure Is Awesome!!! [PART 11]

(-> person
    (assoc :name "John")
    (update :age inc)
    (dissoc :temporary-field))

(->> numbers
     (filter even?)
     (map #(* % 2))
     (reduce +))

(some-> user
        :address
        :city
        str/upper-case)

(def add-five (partial + 5))
(def positive? (partial < 0))

(def format-price
  (comp str/upper-case
        #(str "$ " %)
        #(format "%.2f" %)))

(ns function-composition
  (:require [clojure.string :as str]
            [clojure.pprint :as pp]))

;; === Protocol Definition ===
(defprotocol OrderProcessor
  (process-order [this order]))

;; === Data Processing Pipeline Example ===
(defn clean-string
  "Removes special characters and converts to lowercase"
  [s]
  (-> s
      str/lower-case
      (str/replace #"[^a-z0-9\s]" "")
      str/trim))

(defn word-frequencies
  "Counts word frequencies in a text"
  [text]
  (->> (str/split text #"\s+")
       (map clean-string)
       (filter (complement str/blank?))
       (frequencies)
       (sort-by val >)
       (into {})))

;; === Financial Calculations Pipeline ===
(def tax-rate 0.15)
(def discount-rate 0.10)

(def calculate-tax (partial * (+ 1 tax-rate)))
(def apply-discount (partial * (- 1 discount-rate)))

(def process-price
  (comp (partial format "%.2f")
        apply-discount
        calculate-tax))

;; === Request Processing Pipeline ===
(defn validate-user [request]
  (some-> request
          (assoc :validated true)
          (update :timestamp #(or % (System/currentTimeMillis)))))

(defn enrich-data [request]
  (some-> request
          (assoc :enriched true)
          (update :data merge {:extra "info"})))

(defn format-response [request]
  (some-> request
          (update :data #(select-keys % [:important :fields]))
          (dissoc :internal-only)))

(def process-request
  (comp format-response
        enrich-data
        validate-user))

;; === Order Processing Functions ===
(defn calculate-item-total
  "Calculates total for a single item"
  [{:keys [quantity price]}]
  (* quantity price))

(defn calculate-items-total
  "Calculates total for all items"
  [items]
  (->> items
       (map calculate-item-total)
       (reduce +)))

(defn apply-promotions
  "Applies a sequence of promotional discounts"
  [total promotions]
  (reduce (fn [price discount]
            (- price (* price discount)))
          total
          promotions))

(defn format-money
  "Formats a number as currency"
  [amount]
  (format "$ %.2f" amount))

;; === Order Processor Implementation ===
(defrecord StandardOrderProcessor []
  OrderProcessor
  (process-order [_ {:keys [items promotions]}]
    (let [subtotal (calculate-items-total items)
          total-with-promos (apply-promotions subtotal promotions)]
      {:subtotal subtotal
       :total total-with-promos
       :formatted-total (format-money total-with-promos)
       :items-count (count items)
       :processed-at (java.time.Instant/now)})))

;; === Example Usage and Demonstrations ===
(defn run-examples []
  (println "\n=== Word Frequency Analysis ===")
  (let [text "The quick brown fox jumps over the lazy dog. The FOX is quick!"]
    (println "Original text:" text)
    (println "Word frequencies:")
    (pp/pprint (word-frequencies text)))

  (println "\n=== Financial Calculations ===")
  (let [original-price 100.00]
    (println "Original price:" original-price)
    (println "Processed price:" (process-price original-price)))

  (println "\n=== Request Processing ===")
  (let [request {:data {:important "value"
                       :internal-only "secret"
                       :fields "data"}}]
    (println "Processed request:")
    (pp/pprint (process-request request)))

  (println "\n=== Order Processing ===")
  (let [order {:items [{:quantity 2 :price 10.0}
                       {:quantity 1 :price 25.0}]
               :promotions [0.1 0.05]}
        processor (->StandardOrderProcessor)]
    (println "Processed order:")
    (pp/pprint (process-order processor order))))

(run-examples)