Clojure 多方法与协议：灵活的多态设计与实现

;; 定义一个基于 :shape 字段动态分派的多方法
(defmulti area :shape)

;; 为 :circle 类型定义实现
(defmethod area :circle [shape]
  (* Math/PI (:radius shape) (:radius shape)))

;; 为 :rectangle 类型定义实现
(defmethod area :rectangle [shape]
  (* (:width shape) (:height shape)))

;; 默认实现
(defmethod area :default [shape]
  (throw (ex-info "Unknown shape" {:shape shape})))

;; 使用
(area {:shape :circle :radius 5})       ; => 78.54...
(area {:shape :rectangle :width 4 :height 5}) ; => 20

;; 基于两个参数类型进行分派（类多重分派）
(defmulti encounter (fn [x y] [(:species x) (:species y)]))

(defmethod encounter [:bunny :lion] [b l]
  :run-away)

(defmethod encounter [:lion :bunny] [l b]
  :eat)

(defmethod encounter [:lion :lion] [l1 l2]
  :fight)

(defmethod encounter :default [x y]
  :ignore)

(encounter {:species :bunny} {:species :lion})  ; => :run-away
(encounter {:species :lion} {:species :lion})   ; => :fight

;; 基于数据库类型的动态 SQL 生成
(defmulti generate-sql (fn [query db-config] (:dialect db-config)))

(defmethod generate-sql :mysql [query db-config]
  (str "SELECT * FROM " (:table query) " LIMIT " (:limit query)))

(defmethod generate-sql :postgresql [query db-config]
  (str "SELECT * FROM " (:table query) " FETCH FIRST " (:limit query) " ROWS ONLY"))

(defmethod generate-sql :oracle [query db-config]
  (str "SELECT * FROM (SELECT * FROM " (:table query) ") WHERE ROWNUM <= " (:limit query)))

;; 使用
(generate-sql {:table "users" :limit 10} {:dialect :mysql})
;; => "SELECT * FROM users LIMIT 10"

;; 定义层级关系
(def shape-hierarchy
  (make-hierarchy))

(def shape-hierarchy
  (-> shape-hierarchy
      (derive :square :rectangle)
      (derive :rectangle :polygon)
      (derive :circle :ellipse)))

;; 定义基于自定义层级的多方法
(defmulti compute-area
  :shape
  :hierarchy #'shape-hierarchy)

(defmethod compute-area :polygon [shape]
  (if (= :square (:type shape))
    (* (:side shape) (:side shape))
    (* (:width shape) (:height shape))))

;; :square 会匹配 :polygon 方法
(compute-area {:shape :square :side 5})
; => 25

(defprotocol Printable
  "可被打印为字符串的协议"
  (to-string [this] "返回对象的字符串表示"))

(defprotocol Serializable
  "可序列化接口"
  (to-json [this] "返回 JSON 字符串"))

;; 为 Clojure 内置类型实现 Printable
(extend-type clojure.lang.PersistentVector
  Printable
  (to-string [this]
    (str "[" (clojure.string/join ", " (map to-string this)) "]")))

;; 为 Java String 类实现（Clojure 天然支持）
(extend-type java.lang.String
  Printable
  (to-string [this] this))

(to-string [1 2 3])      ; => "[1, 2, 3]"
(to-string "hello")      ; => "hello"

;; 同时为多类型实现多个方法
(extend-protocol Printable
  java.lang.Number
  (to-string [this] (str this))

  java.lang.Boolean
  (to-string [this] (if this "true" "false"))

  nil
  (to-string [_] "nil"))

;; 定义记录（值语义的数据结构）
(defrecord Person [name age])

;; Record 自动实现了关联函数：
(:name (->Person "Alice" 30))   ; => "Alice"
(assoc (->Person "Alice" 30) :city "NYC") ; => Person{:name "Alice", :age 30, :city "NYC"}

;; 为 Record 实现协议
(defprotocol Greetable
  (greet [this] "打招呼"))

(defrecord Employee [name age department]
  Greetable
  (greet [this]
    (str "Hello, I'm " name " from " department)))

(greet (->Employee "Bob" 25 "Engineering"))
;; => "Hello, I'm Bob from Engineering"

(defprotocol IProcess
  (start [this])
  (stop [this]))

;; 实现 Java 的 Comparable 接口
(defrecord PriorityTask [priority description]
  java.lang.Comparable
  (compareTo [this other]
    (compare (:priority other) (:priority this)))) ; 优先级高的排前面

;; 定义权限协议
(defprotocol IPermission
  (can-access? [this resource action] "检查是否有权限"))

;; Record 类型定义
(defrecord User [id role tenant-id])
(defrecord Admin [id super?])

;; 普通用户实现
(defmethod can-access? User [user resource action]
  (and (= (:tenant-id user) (:tenant-id resource))
       (contains? (get-role-permissions (:role user)) action)))

;; 超级管理员实现
(defmethod can-access? Admin [admin resource action]
  (or (:super? admin)
      (= (:tenant-id admin) (:tenant-id resource))))

;; 使用多方法优化：基于资源类型+角色的多层分派
(defmulti check-permission
  (fn [user resource action]
    [(:role user) (:type resource)]))

(defmethod check-permission [:user :document] [user resource action]
  (and (= (:owner-id resource) (:id user))
       (contains? #{:read :write} action)))

(defmethod check-permission [:manager :document] [user resource action]
  (contains? #{:read :write :delete} action))

;; 结合多方法与协议的完整系统
(defn authorize [user resource action]
  (when-not (can-access? user resource action)
    (throw (ex-info "Forbidden"
                    {:user user :resource resource :action action}))))

;; 多方法的兜底
(defmethod my-method :default [x]
  (println "未识别的类型:" (type x)))

;; 协议的局部实现
(extend-protocol MyProtocol
  Object
  (my-method [this] (default-behavior this)))

(extend-protocol Printable
  nil
  (to-string [_] ""))