多态与多重方法 #

(defmulti greet :type)

(defmethod greet :person [entity]
  (str "Hello, " (:name entity)))

(defmethod greet :robot [entity]
  (str "Beep boop, I am " (:name entity)))

(greet {:type :person :name "Alice"})

(greet {:type :robot :name "R2D2"})

(defmulti name dispatch-fn)

(defmulti area :shape)

(defmulti calculate (fn [x y] (class x)))

(defmulti process first)

(defmethod area :circle [shape]
  (* Math/PI (:radius shape) (:radius shape)))

(defmethod area :rectangle [shape]
  (* (:width shape) (:height shape)))

(area {:shape :circle :radius 5})

(area {:shape :rectangle :width 10 :height 5})

(defmulti greet :type)

(defmethod greet :person [entity]
  (str "Hello, " (:name entity)))

(defmethod greet :default [entity]
  (str "Unknown entity: " entity))

(greet {:type :person :name "Alice"})

(greet {:type :alien :name "ET"})

(defmulti draw :shape)

(defmethod draw :circle [shape]
  (str "Drawing circle with radius " (:radius shape)))

(defmethod draw :rectangle [shape]
  (str "Drawing rectangle " (:width shape) "x" (:height shape)))

(defmulti process (fn [x] (class x)))

(defmethod process String [s]
  (str "String: " s))

(defmethod process Integer [n]
  (str "Integer: " n))

(defmethod process :default [x]
  (str "Unknown: " (class x)))

(process "hello")

(process 42)

(process 3.14)

(defmulti calculate (fn [a b] [(class a) (class b)]))

(defmethod calculate [String String] [a b]
  (str a b))

(defmethod calculate [Integer Integer] [a b]
  (+ a b))

(defmethod calculate [Integer String] [a b]
  (str a b))

(calculate "Hello " "World")

(calculate 1 2)

(calculate 1 " apple")

(defmulti classify
  (fn [item]
    (cond
      (and (map? item) (:error item)) :error
      (map? item) :success
      (coll? item) :collection
      :else :unknown)))

(defmethod classify :error [item]
  (str "Error: " (:message item)))

(defmethod classify :success [item]
  (str "Success: " (:data item)))

(defmethod classify :collection [item]
  (str "Collection with " (count item) " items"))

(classify {:error true :message "Failed"})

(classify {:data "result"})

(classify [1 2 3])

(derive ::dog ::animal)
(derive ::cat ::animal)
(derive ::husky ::dog)

(isa? ::husky ::dog)

(isa? ::husky ::animal)

(isa? ::cat ::dog)

(defmulti speak :type)

(defmethod speak ::animal [entity]
  (str (name (:type entity)) " makes a sound"))

(defmethod speak ::dog [entity]
  (str (name (:type entity)) " barks"))

(defmethod speak ::cat [entity]
  (str (name (:type entity)) " meows"))

(speak {:type ::dog :name "Buddy"})

(speak {:type ::husky :name "Max"})

(speak {:type ::cat :name "Whiskers"})

(parents ::husky)

(ancestors ::husky)

(descendants ::animal)

(def my-hierarchy (make-hierarchy))

(def my-hierarchy
  (-> my-hierarchy
      (derive :mammal :animal)
      (derive :dog :mammal)
      (derive :cat :mammal)))

(defmulti speak-h :type :hierarchy #'my-hierarchy)

(defmethod speak-h :animal [entity]
  "Some sound")

(defmethod speak-h :dog [entity]
  "Woof!")

(defmulti process :type)

(defmethod process :animal [x]
  (str "Animal: " (:name x)))

(defmethod process :pet [x]
  (str "Pet: " (:name x)))

(prefer-method process :pet :animal)

(derive ::dog :animal)
(derive ::dog :pet)

(process {:type ::dog :name "Buddy"})

(defmulti greet :type)

(defmethod greet :person [x] "Hello person")
(defmethod greet :robot [x] "Beep boop")

(methods greet)

(get-method greet :person)

(defmulti test-multi :type)

(defmethod test-multi :a [x] "A")

(remove-method test-multi :a)

(get-method test-multi :a)

(defmulti serialize :format)

(defmethod serialize :json [data]
  (str "{\"value\": " (:value data) "}"))

(defmethod serialize :xml [data]
  (str "<value>" (:value data) "</value>"))

(defmethod serialize :edn [data]
  (str {:value (:value data)}))

(serialize {:format :json :value 42})

(serialize {:format :xml :value 42})

(serialize {:format :edn :value 42})

(defmulti render :shape)

(defmethod render :circle [{:keys [radius center]}]
  (str "Circle at " center " with radius " radius))

(defmethod render :rectangle [{:keys [width height position]}]
  (str "Rectangle " width "x" height " at " position))

(defmethod render :triangle [{:keys [vertices]}]
  (str "Triangle with vertices " vertices))

(render {:shape :circle :radius 5 :center [0 0]})

(render {:shape :rectangle :width 10 :height 5 :position [1 1]})

(defmulti process-payment :method)

(defmethod process-payment :credit-card [{:keys [card-number amount]}]
  {:status :success
   :message (str "Charged $" amount " to card ending in "
                 (subs card-number (- (count card-number) 4)))})

(defmethod process-payment :paypal [{:keys [email amount]}]
  {:status :success
   :message (str "Charged $" amount " via PayPal to " email)})

(defmethod process-payment :bank-transfer [{:keys [account amount]}]
  {:status :pending
   :message (str "Transfer of $" amount " initiated to account " account)})

(process-payment {:method :credit-card :card-number "1234567890123456" :amount 100})

(process-payment {:method :paypal :email "user@example.com" :amount 50})

(defmulti validate :type)

(defmethod validate :string [{:keys [value min-len max-len]}]
  (cond
    (< (count value) (or min-len 0))
    {:valid false :error "Too short"}
    (> (count value) (or max-len Integer/MAX_VALUE))
    {:valid false :error "Too long"}
    :else
    {:valid true}))

(defmethod validate :number [{:keys [value min max]}]
  (cond
    (< value (or min Integer/MIN_VALUE))
    {:valid false :error "Too small"}
    (> value (or max Integer/MAX_VALUE))
    {:valid false :error "Too large"}
    :else
    {:valid true}))

(validate {:type :string :value "hello" :min-len 1 :max-len 10})

(validate {:type :number :value 5 :min 1 :max 10})