使用clojure宏在reify调用中自动创建getter和setter [英] Use a clojure macro to automatically create getters and setters inside a reify call
问题描述
(def data(atom {:x nil}))
(reify HugeInterface
(getX [this](:x @data))
(setX [this v](swap!data assoc:xv)))
我想能写
(def data(atom {:x nil}))
(reify HugeInterface
(set-and-get getX setX:x))
b $ b这个set-and-get宏(或类似的东西)可能吗?
解决方案(更新了第二种方法 - 第二条横线规则 - 以及一些解释性说明:第一条。)
如果这可能是正确方向的一步:
(defmacro reify-from-maps [iface implicits-map emit-map & ms]
`(reify〜iface
〜@(apply concat
(for [[mname& args:as m] ms]
(if-let [emit ((关键字mname)emit-map)]
(apply emit implicits-map args)
[m]))))bbb
(def emit-atom-g& ss
{:set-and-get(fn [implicits-map gname sname k]
[`(〜gname [〜'this](〜k @〜(:atom-name implicits-map) ))
`(〜sname [〜'this〜'v]
(swap!〜(:atom-name implicits-map)assoc〜k〜'v))])})
(defmacro atom-bean [iface a& ms]
`(reify-from-maps〜iface {:atom-name〜a}〜emit-atom-g& ss〜@ ms) )
注意。
atom-bean
宏传递emit-atom-g& ss $的实际编译时值 c $ c>到
reify-from-maps
。一旦编译了特定的atom-bean
形式,对emit-atom-g& ss
的任何后续更改都没有效果
来自REPL的宏展开示例(为了清晰起见,添加了一些换行符和缩进):
user> ( - >'(atom-bean HugeInterface data
(set-and-get setX getX:x))
macroexpand-1
macroexpand-1)
(clojure.core / reify HugeInterface
(setX [this](:x(clojure.core / deref data)))
(getX [this v](clojure.core / swap!data clojure.core / assoc:xv )))
两个
macroexpand-1
是必要的,因为atom-bean
是一个宏,扩展到另一个宏调用。宏展开
将不会特别有用,因为它会将此扩展为对reify *
的调用,reify 。
这里的想法是你可以提供
emit- map
如上所述的
emit-atom-g& ss
,其关键字的名称(符号形式)将触发reify-from-maps
调用。魔法由存储为给定emit-map
中的函数的函数执行;函数的参数是implicits的映射(基本上是reify-from-maps
形式的所有方法定义都应该可以访问的任何和所有信息,例如在这种情况下,原子的名称),然后是在reify-from-maps
表单中给魔法方法说明符的任何参数。如上所述,reify-from-maps
需要查看实际的关键字 - >函数映射,而不是它的符号名称;所以,它只真正可用于字面地图,其他宏或帮助eval
。
正常方法定义仍然可以包含,并且将被视为常规
reify
表单中处理,只要匹配其名称的键不会出现在emit-map
。 emit函数必须以reify
:期望的格式返回方法定义的seqables(例如向量):以这种方式,返回一个魔法方法说明符的多个方法定义的情况比较简单。如果iface
参数替换为ifaces
和〜iface
与〜@ ifaces
在reify-from-maps
'体中,可以指定多个接口来实现。 >
这里是另一种方法,可能更容易推理:
(defn compile-atom-bean-converter [ifaces get-set-map]
(eval
(let [asym(gensym)]
` 〜asym]
(reify〜@ ifaces
〜@(apply concat
(for [[k [gs]] get-set-map]
[` 〜this(〜k @〜asym))
`(〜s this〜'v]
(swap!〜asym assoc〜k〜 )))
这在运行时调用编译器,这有点贵,但只需要对每组要实现的接口执行一次。结果是一个函数,它接受一个原子作为参数,并使用在
get-set-map
参数中指定的getter和setter来实现给定接口的原子。 (这样写,这比以前的方法灵活,但是上面的大多数代码可以在这里重用。)
这里有一个示例接口和getter / setter map:
(definterface IFunky
(getFoo [])
(^ void setFoo [v])
(getFunkyBar [])
(^ void setWeirdBar [v]))
(def gsm
'{:foo [getFoo setFoo] bar [getFunkyBar setWeirdBar]})
和一些REPL交互:
user> (def data {:foo 1:bar 2})
#'user / data
user> (def atom-bean-converter(compile-atom-bean-converter'[IFunky] gsm))
#'user / atom-bean-converter
user> (def atom-bean(atom-bean-converter data))
#'user / atom-bean
user> (.setFoo data-bean 3)
nil
user> (.getFoo atom-bean)
3
user> (.getFunkyBar data-bean)
2
user> (.setWeirdBar data-bean 5)
nil
user> (.getFunkyBar data-bean)
5
I am trying to implement a huge Java interface with numerous (~50) getter and setter methods (some with irregular names). I thought it would be nice to use a macro to reduce the amount of code. So instead of
(def data (atom {:x nil})) (reify HugeInterface (getX [this] (:x @data)) (setX [this v] (swap! data assoc :x v)))
I want to be able to write
(def data (atom {:x nil})) (reify HugeInterface (set-and-get getX setX :x))
Is this set-and-get macro (or something similar) possible? I haven't been able to make it work.
解决方案(Updated with a second approach -- see below the second horizontal rule -- as well as some explanatory remarks re: the first one.)
I wonder if this might be a step in the right direction:
(defmacro reify-from-maps [iface implicits-map emit-map & ms] `(reify ~iface ~@(apply concat (for [[mname & args :as m] ms] (if-let [emit ((keyword mname) emit-map)] (apply emit implicits-map args) [m]))))) (def emit-atom-g&ss {:set-and-get (fn [implicits-map gname sname k] [`(~gname [~'this] (~k @~(:atom-name implicits-map))) `(~sname [~'this ~'v] (swap! ~(:atom-name implicits-map) assoc ~k ~'v))])}) (defmacro atom-bean [iface a & ms] `(reify-from-maps ~iface {:atom-name ~a} ~emit-atom-g&ss ~@ms))
NB. that the
atom-bean
macro passes the actual compile-time value ofemit-atom-g&ss
on toreify-from-maps
. Once a particularatom-bean
form is compiled, any subsequent changes toemit-atom-g&ss
have no effect on the behaviour of the created object.An example macroexpansion from the REPL (with some line breaks and indentation added for clarity):
user> (-> '(atom-bean HugeInterface data (set-and-get setX getX :x)) macroexpand-1 macroexpand-1) (clojure.core/reify HugeInterface (setX [this] (:x (clojure.core/deref data))) (getX [this v] (clojure.core/swap! data clojure.core/assoc :x v)))
Two
macroexpand-1
s are necessary, becauseatom-bean
is a macro which expands to a further macro call.macroexpand
would not be particularly useful, as it would expand this all the way to a call toreify*
, the implementation detail behindreify
.The idea here is that you can supply an
emit-map
likeemit-atom-g&ss
above, keyed by keywords whose names (in symbolic form) will trigger magic method generation inreify-from-maps
calls. The magic is performed by the functions stored as functions in the givenemit-map
; the arguments to the functions are a map of "implicits" (basically any and all information which should be accessible to all method definitions in areify-from-maps
form, like the name of the atom in this particular case) followed by whichever arguments were given to the "magic method specifier" in thereify-from-maps
form. As mentioned above,reify-from-maps
needs to see an actual keyword -> function map, not its symbolic name; so, it's only really usable with literal maps, inside other macros or with help ofeval
.Normal method definitions can still be included and will be treated as in a regular
reify
form, provided keys matching their names do not occur in theemit-map
. The emit functions must return seqables (e.g. vectors) of method definitions in the format expected byreify
: in this way, the case with multiple method definitions returned for one "magic method specifier" is relatively simple. If theiface
argument were replaced withifaces
and~iface
with~@ifaces
inreify-from-maps
' body, multiple interfaces could be specified for implementation.
Here's another approach, possibly easier to reason about:
(defn compile-atom-bean-converter [ifaces get-set-map] (eval (let [asym (gensym)] `(fn [~asym] (reify ~@ifaces ~@(apply concat (for [[k [g s]] get-set-map] [`(~g [~'this] (~k @~asym)) `(~s [~'this ~'v] (swap! ~asym assoc ~k ~'v))])))))))
This calls on the compiler at runtime, which is somewhat expensive, but only needs to be done once per set of interfaces to be implemented. The result is a function which takes an atom as an argument and reifies a wrapper around the atom implementing the given interfaces with getters and setters as specified in the
get-set-map
argument. (Written this way, this is less flexible than the previous approach, but most of the code above could be reused here.)Here's a sample interface and a getter/setter map:
(definterface IFunky (getFoo []) (^void setFoo [v]) (getFunkyBar []) (^void setWeirdBar [v])) (def gsm '{:foo [getFoo setFoo] :bar [getFunkyBar setWeirdBar]})
And some REPL interactions:
user> (def data {:foo 1 :bar 2}) #'user/data user> (def atom-bean-converter (compile-atom-bean-converter '[IFunky] gsm)) #'user/atom-bean-converter user> (def atom-bean (atom-bean-converter data)) #'user/atom-bean user> (.setFoo data-bean 3) nil user> (.getFoo atom-bean) 3 user> (.getFunkyBar data-bean) 2 user> (.setWeirdBar data-bean 5) nil user> (.getFunkyBar data-bean) 5
这篇关于使用clojure宏在reify调用中自动创建getter和setter的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!