condcast-> example

condcast_example.clj

(import '[UnityEngine Quaternion Vector3])

(set! *warn-on-reflection* true)

;; note this takes an optional default value. This macro is potentially
;; annoying in the case that you want to branch on a supertype, for
;; instance, but the cast would remove interface information. Use with
;; this in mind.
(defmacro condcast-> [expr xsym & clauses]
  (let [exprsym (gensym "exprsym_")
        [clauses default] (if (even? (count clauses))
                            [clauses nil] 
                            [(butlast clauses)
                             [:else
                              `(let [~xsym ~exprsym]
                                 ~(last clauses))]])
        cs (->> clauses
             (partition 2)
             (mapcat
               (fn [[t then]]
                 `[(instance? ~t ~exprsym)
                   (let [~(with-meta xsym {:tag t}) ~exprsym]
                     ~then)])))]
    `(let [~exprsym ~expr]
       ~(cons 'cond
          (concat cs default)))))

;; throws reflection warning:
(defn q* [^Quaternion q x]
  (Quaternion/op_Multiply q x))

;; no reflection warning:
(defn q* [^Quaternion q x]
  (condcast-> x x
    Vector3    (Quaternion/op_Multiply q x)
    Quaternion (Quaternion/op_Multiply q x)))

stopgap for evading reflection with runtime type tests/casting until we develop something better (probably more of the same but with core.match)

(defn q* [^Quaternion q x]
  (condcast-> x x
    Vector3    (Quaternion/op_Multiply q x)
    Quaternion (Quaternion/op_Multiply q x)))

is equivalent to

(defn q*  [^Quaternion q x]
  (let [exprsym_142 x]
    (cond
      (instance? Vector3 exprsym_142)
      (let [^Vector3 x exprsym_142]
        (Quaternion/op_Multiply q x))
      (instance? Quaternion exprsym_142)
      (let [^Quaternion x exprsym_142]
        (Quaternion/op_Multiply q x)))))