d21ab77e7e
Shaking out clojure.core.memoize (207 assertions, 0 fail) cleared several
general gaps:
- deref/@ on a deftype or reify implementing clojure.lang.IDeref dispatches to
its deref method (RetryingDelay / make-derefable).
- deftype mutable fields (^:unsynchronized-mutable / ^:volatile-mutable) are
read live: a set! within a method is observed by a later read in the same
invocation, not the entry-time capture. Needed for double-checked locking.
Immutable fields stay let-bound. Field reads rewrite to (.-field inst) with
lexical-shadow tracking.
- def metadata values are evaluated, like Clojure: ^{:k (f)} stores (f)'s
result and ^{:af some-fn} the fn. :tag stays a literal hint.
- try dispatches catch clauses by class in order via the exception supertype
hierarchy; a non-matching value re-throws, an untyped host condition is caught
by a RuntimeException/Exception/Throwable clause. Previously the last clause
won and the class was ignored.
- locking takes a real per-object monitor (recursive Chez mutex) now that
futures/agents/threads share one heap; it was a no-op.
- supers/ancestors reflect a small modeled JVM interface hierarchy, so
(ancestors (class f)) yields Runnable/Callable (core.memoize's arg check).
- AssertionError / Error constructors.
JOLT_FEATURES is gone from the docs: it isn't read anywhere on Chez, and the
reader already includes :clj in its default feature set. RFC 0002's
{:jolt :default} design was reverted in the reader; docs now match the code.
Raises the SCI floor 205 -> 210.
33 lines
1.3 KiB
Clojure
33 lines
1.3 KiB
Clojure
;; Verbatim from clojure.template (Stuart Sierra) — pure Clojure over
|
|
;; clojure.walk, which jolt ships. Added so honeysql's :clj branch (which
|
|
;; requires clojure.template) loads.
|
|
(ns clojure.template
|
|
"Macros that expand to repeated copies of a template expression."
|
|
(:require [clojure.walk :as walk]))
|
|
|
|
(defn apply-template
|
|
"For use in macros. argv is an argument list, as in defn. expr is
|
|
a quoted expression using the symbols in argv. values is a sequence
|
|
of values to be used for the arguments.
|
|
|
|
apply-template will recursively replace argument symbols in expr
|
|
with their corresponding values, returning a modified expr.
|
|
|
|
Example: (apply-template '[x] '(+ x x) '[2])
|
|
;=> (+ 2 2)"
|
|
[argv expr values]
|
|
(assert (vector? argv))
|
|
(assert (every? symbol? argv))
|
|
(walk/postwalk-replace (zipmap argv values) expr))
|
|
|
|
(defmacro do-template
|
|
"Repeatedly copies expr (in a do block) for each group of arguments
|
|
in values. values are automatically partitioned by the number of
|
|
arguments in argv, an argument vector as in defn.
|
|
|
|
Example: (macroexpand '(do-template [x y] (+ y x) 2 4 3 5))
|
|
;=> (do (+ 4 2) (+ 5 3))"
|
|
[argv expr & values]
|
|
(let [c (count argv)]
|
|
`(do ~@(map (fn [a] (apply-template argv expr a))
|
|
(partition c values)))))
|