Hi,

Am 26.05.2009 um 20:47 schrieb kyle smith:

Ahh, of course. I've actually learned that trick before. Thanks.

There is also the mega-hacky quasiquote macro:

(defn- self-eval?
  [thing]
  (or (keyword? thing)
      (number? thing)
      (instance? Character thing)
      (string? thing)
      (nil? thing)))

(defn- flatten-map
  [the-map]
  (reduce (fn [result entry] (-> result
                               (conj (key entry))
                               (conj (val entry))))
          [] the-map))

(defn- unquote?
  [form]
  (and (seq? form) (= (first form) `unquote)))

(defn- quasiquote*
  [form]
  (cond
    (self-eval? form) form
    (unquote? form)   (second form)
    (symbol? form)    (list 'quote form)
    (vector? form)    (vec (map quasiquote* form))
(map? form) (apply hash-map (map quasiquote* (flatten-map form)))
    (set? form)       (apply hash-set (map quasiquote* form))
    (seq? form)       (list* `list (map quasiquote* form))
    :else             (list 'quote form)))

(defmacro quasiquote
  [form]
  (quasiquote* form))

So (let [x 5] (quasiquote (+ ~x 6))) will result in (+ 5 6).

Sincerely
Meikel

Attachment: smime.p7s
Description: S/MIME cryptographic signature

Reply via email to