3

OK, I want to write a Clojure macro that defines a struct-map and let caller to specify types for each field.

The signature will look like this:

(defmodel category :id Integer :name String)

What this does is it creates a struct-map called category, and also create a binding *category-meta*, which is a map {:id Integer :name String}

Here's my macro to achieve this:

(defmacro defmodel [name & field-spec]
    `(let [fields# (take-nth 2 ~@field-spec)]
        (defstruct ~name fields#)
        (def *~name-meta* (reduce #(assoc %1 (first %2) (last %2))) (partition 2 ~@field-spec))))

However, the problem is, I cannot define a binding whose name is composed of another name. Basically, (def *~name-meta* ...) doesn't work.

How am I able to achieve this?

Thanks.

EnToutCas
  • 1,297
  • 2
  • 15
  • 20

1 Answers1

4

(Updated with a debugged version of the macro from the question text.)

This should work as specified:

(defmacro defmodel [name & field-spec]
  `(do (defstruct ~name ~@(take-nth 2 field-spec))
       (def ~(symbol (str "*" name "-meta*"))
         (reduce #(assoc %1 (first %2) (last %2))
                 {}
                 (partition 2 '~field-spec)))))

The answer to the main question is to use ~(symbol (str "*" name "-meta*")) in place of *~name-meta*. ~ unquotes the next expression in a syntax-quoted form, injecting its return value in the appropriate spot of the given list structure.

Some other modifications were necessary -- in particular, defstruct requires that the keys be supplied to it as separate arguments, rather than a single seq (or the name of a variable holding such a seq), reduce needs the explicit seed value to work here etc.

Incidentally, unless you need to stick to Clojure 1.1, you might want to use 1.2's defrecord in preference to defstruct -- in fact, the latter is deprecated in 1.2.

Michał Marczyk
  • 83,634
  • 13
  • 201
  • 212
  • Thanks for your clear answer. I looked at defrecord before, but the main shortcoming is that you have to provide all the field values at initialization time. e.g., (defrecord category [^String id ^String name]), and I have to call it like this `(category. 1 "stack")`. I cannot do something like (category. {:id 1 :name "Stack"}), or (category. 1), i.e., allow default parameters. Seems like record support is still tentative and may change any time. Feel free to chime in and tell me whatever I haven't known about records so far :) – EnToutCas Nov 26 '10 at 22:33
  • I would consider writing a contractor that does what you want. records are faster and the can implement protocols. Some more powerful records can be found here https://github.com/david-mcneil/defrecord2 – nickik Nov 27 '10 at 13:46
  • @EnToutCas: I wouldn't call record support tentative -- struct maps really *have* been deprecated after all, with records being the suggested replacement. (That's without saying anything about the likelihood of some convention on factory functions possibly finding its way into the core library in the future.) As for your specific issues, I'm basically in agreement with nickik. (In fact, I find it useful to write factory functions for nearly all my records, if only to be able to `:require` them later without `:import`-ing all the records.) @nickik: Thanks for the link! – Michał Marczyk Nov 27 '10 at 21:15
  • @EnToutCas: Oh, one more thing. In Clojure, it often makes perfect sense to use a plain ol' map in preference to either a struct map or a record. Have you considered that? (Plus custom functions doing the job of `assoc` & Co. while performing data type checks against your `*foo-meta*` Vars, perhaps.) – Michał Marczyk Nov 27 '10 at 21:21
  • @Michal, I thought struct-maps are maps with pre-defined keys, no? – EnToutCas Nov 29 '10 at 16:52
  • @EnToutCas: Right, but there's often no great advantage to using them in preference to regular maps with the same (albeit not predefined) keys; and any advantage there is is more pronounced with records. So, if you're looking to save some memory and speed up accesses to pre-defined keys, you'll be better off with records; if they're not worth the trouble, struct maps might not be either. – Michał Marczyk Nov 29 '10 at 17:04
  • @Michal, I see. I will research more on records. Since records are implemented as Java classes under the hood, is there a way to initialize records with a map without using Java's horrendous reflection methods? Thanks. – EnToutCas Nov 29 '10 at 18:01
  • @EnToutCas: You might want to look into the link posted by nickik above. Long story short, you'll likely want to write some factory functions. (Maybe rewrite the `defmodel` macro to define a record and a factory function doing some type validation.) – Michał Marczyk Nov 29 '10 at 18:07