clojure.core/reify

View this page on ClojureDocs

Type: macro Added: Clojure 1.2 Examples: 8 Runnable: 0

([& opts+specs])

reify creates an object implementing a protocol or interface. reify is a macro with the following structure:

(reify options* specs*)

Currently there are no options.

Each spec consists of the protocol or interface name followed by zero or more method bodies:

protocol-or-interface-or-Object (methodName [args+] body)*

Methods should be supplied for all methods of the desired protocol(s) and interface(s). You can also define overrides for methods of Object. Note that the first parameter must be supplied to correspond to the target object ('this' in Java parlance). Thus methods for interfaces will take one more argument than do the interface declarations. Note also that recur calls to the method head should not pass the target object, it will be supplied automatically and can not be substituted.

The return type can be indicated by a type hint on the method name, and arg types can be indicated by a type hint on arg names. If you leave out all hints, reify will try to match on same name/arity method in the protocol(s)/interface(s) - this is preferred. If you supply any hints at all, no inference is done, so all hints (or default of Object) must be correct, for both arguments and return type. If a method is overloaded in a protocol/interface, multiple independent method definitions must be supplied. If overloaded with same arity in an interface you must specify complete hints to disambiguate - a missing hint implies Object.

Method heads are recursion points for recur, as in a fn. The method bodies of reify are lexical closures, and can refer to the surrounding local scope:

(str (let [f "foo"] (reify Object (toString [this] f)))) == "foo"

(seq (let [f "foo"] (reify clojure.lang.Seqable (seq [this] (seq f))))) == (\f \o \o)

reify always implements clojure.lang.IObj and transfers meta data of the form to the created object.

(meta ^{:k :v} (reify Object (toString [this] "foo"))) == {:k :v}

Examples

by yasuto on 2011-09-10 . May have evaluation errors. ▶

(ns foo) ;;; This is a library for the shopping result. (defrecord Banana [qty]) (defrecord Grape [qty]) (defrecord Orange [qty]) ;;; 'subtotal' differs from each fruit. (defprotocol Fruit (subtotal [item])) (extend-type Banana Fruit (subtotal [item] (* 158 (:qty item)))) (extend-type Grape Fruit (subtotal [item] (* 178 (:qty item)))) (extend-type Orange Fruit (subtotal [item] (* 98 (:qty item)))) ;;; 'coupon' is the function returing a 'reify' of subtotal. This is ;;; when someone uses a coupon ticket, the price of some fruits is ;;; taken off 25%. (defn coupon [item] (reify Fruit (subtotal [_] (int (* 0.75 (subtotal item)))))) ;;; Example: To compute the total when someone bought 10 oranges, ;;; 15 bananas and 10 grapes, using a coupon for the grapes. (apply + (map subtotal [(Orange. 10) (Banana. 15) (coupon (Grape. 10))])) ;;; 4685 ; (apply + '(980 2370 1335))

by number23 on 2012-06-08 . May have evaluation errors. ▶

;; Using a reified FileFilter implementation to obtain only directory files (.listFiles (java.io.File. ".") (reify java.io.FileFilter (accept [this f] (.isDirectory f))))

by puredanger on 2012-12-18 . May have evaluation errors. ▶

;;;; This example shows how to reify a multi-arity protocol function ;;;; (note the different style in defprotocol vs reify) ;; define a multi-arity protocol function blah (defprotocol Foo (blah [this x] [this x y])) ;; define an anonymous extension via reify (def r (reify Foo (blah [_ x] x) (blah [_ x y] y))) ;; invoke blah via the r instance (blah r 1) ;; => 1 (blah r 1 2) ;; => 2

by PetrGlad on 2015-01-05 . May have evaluation errors. ▶

;; Note that nested class is referred via '$' ;; and 'this' is always present in parameters (see underscore in parameters list): (Thread/setDefaultUncaughtExceptionHandler (reify java.lang.Thread$UncaughtExceptionHandler (uncaughtException [_ thread throwable] (println (str throwable)))))

by yubrshen on 2015-08-24 . May have evaluation errors. ▶

;;; This example is inspired by the above one and simplified ;;; to highlight reify's returning a value/"object" ;;; with protocol realization for just this one piece of value/"object". (ns foo) (defrecord Grape [qty]) (defprotocol Fruit (subtotal [item])) (extend-type Grape Fruit (subtotal [item] (* 178 (:qty item)))) ;;; 'discounted' is the function returning a 'reify' instance of fruit with modified ;;; implementation of subtotal (with discount). That is, ;;; when someone uses a discounted coupon, the price of the fruits is taken off 25%. (defn discounted [item] (reify Fruit (subtotal [_] (println "modifying subtotal with discount:") (int (* 0.75 (subtotal item)))))) ;;; Example: ;;; There is 10 pieces of Grape, and the subtotal before discount is ;;; (subtotal (Grape. 10)) ;;; => 1780 ;;; With discount, then ;;; (subtotal (discounted (Grape. 10))) ;;; => modifying subtotal with discount: ;;; => 1335

by clojureling on 2016-05-21 . May have evaluation errors. ▶

(comment "reify verb | re·ify | \\ˈrā-ə-ˌfī, ˈrē-\\ : to regard (something abstract) as a material or concrete thing") (defprotocol shape "A geometric shape." (area [this] "Calculates the area of the shape. The first argument is required and corresponds to the implicit target object ('this' in Java parlance).")) (defn make-circle "Creates a circle (a geometric shape) object." [radius] (reify shape (area [_] (* Math/PI radius radius)))) (. (make-circle 8) area) ;;=> 201.06192982974676 (def circle (make-circle 8)) (satisfies? shape circle) ;;=> true (. circle area) ;;=> 201.06192982974676 (defn make-triangle "Creates a triangle (a geometric shape) object." [base height] (reify shape (area [_] (* 0.5 base height)))) (def triangle (make-triangle 8 8)) (. triangle area) ;;=> 32.0

by RokLenarcic on 2021-02-11 . May have evaluation errors. ▶

;; Attaching metadata to reify object creates a new instance ;; Reify call itself attaches metadata of (reify ...) form to the object ;; so effectively it always creates two objects but return one of them. ;; This matters when you use finalize (defn create [] (reify Object (finalize [this] (println "GCing" this) nil))) (do (create) (System/gc)) ;;GCing #object[.$create$reify__7691 0x3b287fd2 .$create$reify__7691@3b287fd2] ;;GCing #object[.$create$reify__7691 0x38249fdc .$create$reify__7691@38249fdc] ;;=> nil

by huahaiy on 2022-11-26 . May have evaluation errors. ▶

(defprotocol Foo (foo-f [this])) (defprotocol Bar (bar-f [this])) ;; It is fine to reify multiple protocol/interfaces (def foo-bar (reify Foo (foo-f [_] :foo) Bar (bar-f [_] :bar))) (foo-f foo-bar) ;;=>:foo (bar-f foo-bar) ;;=>:bar

Note by ieugen

reify can implement multiple interfaces:

(let [a (reify
            java.lang.AutoCloseable
            (close [_this]
              (println "aaa"))
            java.lang.Runnable
            (run [_this]
              (println "Run")))]
    (.close a)
    (.run a))

Note that methods in reify DO NOT accept docstrings like clojure defn's , although they look very similar. You will get compilation error with method not found if you use a docstring.

Something like this

; Evaluating file: java_map.clj
; Syntax error (IllegalArgumentException) compiling reify* at (src/java_map.clj:27:5).
; Can't define method not in interfaces: close
; Evaluation of file java_map.clj failed: class clojure.lang.Compiler$CompilerException

Note by ieugen

Sometimes you will need to add type hints. This is mandatory if there are overloaded methods.

One such case is when implementing java.util.Collection toArray .

Without type hints, you will get

Mismatched return type: toArray, expected: [Ljava.lang.Object;, had: java.lang.Object

A correct way to handle this is like bellow.

Note: when you add one type hint, you need to add for all methods in reify. See docs above.

(reify java.util.Collection
    (^boolean containsAll [_this ^java.util.Collection c])
    (^objects toArray [_this]
      (throw (UnsupportedOperationException.)))
    (^objects toArray [_this ^objects objects]
      (throw (UnsupportedOperationException.))))

https://github.com/clojure/data.avl/commit/03f32144951ab7b50b8a74ea5e8c22629e7fbde0

See also

• clojure.core/proxy (1)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.