Added uniform metadata handling for atoms/refs/agents/vars/namespaces

Note - breaking change for agent/ref when supplying validator - validator must be passed using :validator option
Added :validator and :meta options to agent/ref/atom
Added alter-meta! and reset-meta! for reference types
renamed set-validator to set-validator!
Validators now can simply return false, or throw
Refactoring, added IMeta, IReference
Switched to longs for Ref ids

Author: richhickey

src/clj/clojure/core.clj

@@ -150,8 +150,8 @@
  #^{:arglists '([obj])
     :doc "Returns the metadata of obj, returns nil if there is no metadata."}
  meta (fn meta [x]
-        (if (instance? clojure.lang.IObj x)
-          (. #^clojure.lang.IObj x (meta)))))
+        (if (instance? clojure.lang.IMeta x)
+          (. #^clojure.lang.IMeta x (meta)))))
 
 (def
  #^{:arglists '([#^clojure.lang.IObj obj m])
@@ -1047,14 +1047,31 @@
  [sym] (. clojure.lang.Var (find sym)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Refs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn #^{:private true}
+  setup-reference [r options]
+  (let [opts (apply hash-map options)]
+    (when (:meta opts)
+      (.resetMeta r (:meta opts)))
+    (when (:validator opts)
+      (.setValidator r (:validator opts)))
+    r))
+
 (defn agent
-  "Creates and returns an agent with an initial value of state and an
-  optional validate fn. validate-fn must be nil or a side-effect-free fn of
-  one argument, which will be passed the intended new state on any state
+  "Creates and returns an agent with an initial value of state and
+  zero or more options (in any order):
+  
+  :meta metadata-map
+  
+  :validator validate-fn
+
+  If metadata-map is supplied, it will be come the metadata on the
+  agent. validate-fn must be nil or a side-effect-free fn of one
+  argument, which will be passed the intended new state on any state
   change. If the new state is unacceptable, the validate-fn should
-  throw an exception."
+  return false or throw an exception."
   ([state] (new clojure.lang.Agent state))
-  ([state validate-fn] (new clojure.lang.Agent state validate-fn)))
+  ([state & options]
+     (setup-reference (agent state) options)))
 
 (defn send
   "Dispatch an action to an agent. Returns the agent immediately.
@@ -1119,14 +1136,21 @@
   [] (. clojure.lang.Agent shutdown))
 
 (defn ref
-  "Creates and returns a Ref with an initial value of x and an optional validate fn.
-  validate-fn must be nil or a side-effect-free fn of one argument, which will
-  be passed the intended new state on any state change. If the new
-  state is unacceptable, the validate-fn should throw an
-  exception. validate-fn will be called on transaction commit, when
-  all refs have their final values."  
+  "Creates and returns a Ref with an initial value of x and zero or
+  more options (in any order):
+  
+  :meta metadata-map
+  
+  :validator validate-fn
+
+  If metadata-map is supplied, it will be come the metadata on the
+  ref. validate-fn must be nil or a side-effect-free fn of one
+  argument, which will be passed the intended new state on any state
+  change. If the new state is unacceptable, the validate-fn should
+  return false or throw an exception. validate-fn will be called on
+  transaction commit, when all refs have their final values." 
   ([x] (new clojure.lang.Ref x))
-  ([x validate-fn] (new clojure.lang.Ref x validate-fn)))
+  ([x & options] (setup-reference (ref x) options)))
 
 (defn deref
   "Also reader macro: @ref/@agent/@var/@atom Within a transaction,
@@ -1135,11 +1159,45 @@
   or atom, returns its current state."  
   [#^clojure.lang.IRef ref] (. ref (get)))
 
-(defn set-validator
+(defn atom
+  "Creates and returns an Atom with an initial value of x and zero or
+  more options (in any order):
+  
+  :meta metadata-map
+  
+  :validator validate-fn
+
+  If metadata-map is supplied, it will be come the metadata on the
+  atom. validate-fn must be nil or a side-effect-free fn of one
+  argument, which will be passed the intended new state on any state
+  change. If the new state is unacceptable, the validate-fn should
+  return false or throw an exception."
+  ([x] (new clojure.lang.Atom x))
+  ([x & options] (setup-reference (atom x) options)))
+
+(defn swap!
+  "Atomically swaps the value of atom to be:
+  (apply f current-value-of-atom args). Note that f may be called
+  multiple times, and thus should be free of side effects.  Returns
+  the value that was swapped in."  
+  [#^clojure.lang.Atom atom f & args] (.swap atom f args))
+
+(defn compare-and-set! 
+  "Atomically sets the value of atom to newval if and only if the
+  current value of the atom is identical to oldval. Returns true if
+  set happened, else false" 
+  [#^clojure.lang.Atom atom oldval newval] (.compareAndSet atom oldval newval))
+
+(defn reset! 
+  "Sets the value of atom to newval without regard for the
+  current value. Returns newval." 
+  [#^clojure.lang.Atom atom newval] (.reset atom newval))
+
+(defn set-validator!
   "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
   side-effect-free fn of one argument, which will be passed the intended
   new state on any state change. If the new state is unacceptable, the
-  validator-fn should throw an exception. If the current state (root
+  validator-fn should return false or throw an exception. If the current state (root
   value if var) is not acceptable to the new validator, an exception
   will be thrown and the validator will not be changed." 
   [#^clojure.lang.IRef iref validator-fn] (. iref (setValidator validator-fn)))
@@ -1148,6 +1206,18 @@
   "Gets the validator-fn for a var/ref/agent/atom."
  [#^clojure.lang.IRef iref] (. iref (getValidator)))
 
+(defn alter-meta!
+  "Atomically sets the metadata for a namespace/var/ref/agent/atom to be: 
+  
+  (apply f its-current-meta args) 
+  
+  f must be free of side-effects"
+ [#^clojure.lang.IReference iref f & args] (.alterMeta iref f args))
+
+(defn reset-meta!
+  "Atomically resets the metadata for a namespace/var/ref/agent/atom"
+ [#^clojure.lang.IReference iref metadata-map] (.resetMeta iref metadata-map))
+
 (defn commute
   "Must be called in a transaction. Sets the in-transaction-value of
   ref to:

src/clj/clojure/core_proxy.clj

@@ -339,57 +339,5 @@
 		    (lazy-cons (new clojure.lang.MapEntry (first pseq) (v (first pseq)))
 			       (thisfn (rest pseq))))) (keys pmap))))))
 
-(import '(java.util.concurrent.atomic AtomicReference))
 
-(defn atom
-  "Creates and returns a new Atom with an initial value of x and an
-  optional validate fn. validate-fn must be nil or a side-effect-free
-  fn of one argument, which will be passed the intended new state on
-  any state change. If the new state is unacceptable, the validate-fn
-  should throw an exception."
-  ([x] (atom x nil))
-  ([x validator-fn]
-     (let [validator (AtomicReference. nil)
-           atom (proxy [AtomicReference clojure.lang.IRef] [x]
-                  (getValidator [] (.get validator))
-                  (setValidator [f]
-                    (when f
-                      (try
-                       (f @this)
-                       (catch Exception e
-                         (throw (IllegalStateException. "Invalid atom state" e)))))
-                    (.set validator f)))]
-       (set-validator atom validator-fn)
-       atom)))
-
-(defn swap!
-  "Atomically swaps the value of atom to be:
-  (apply f current-value-of-atom args). Note that f may be called
-  multiple times, and thus should be free of side effects.  Returns
-  the value that was swapped in."  
-  [#^AtomicReference atom f & args]
-  (let [validate (get-validator atom)]
-    (loop [oldv (.get atom)]
-      (let [newv (apply f oldv args)]
-        (when validate
-          (try
-           (validate newv)
-           (catch Exception e
-             (throw (IllegalStateException. "Invalid atom state" e)))))
-        (if (.compareAndSet atom oldv newv)
-          newv
-          (recur (.get atom)))))))
-
-(defn compare-and-set! 
-  "Atomically sets the value of atom to newval if and only if the
-  current value of the atom is identical to oldval. Returns true if
-  set happened, else false" 
-  [#^AtomicReference atom oldval newval]
-    (let [validate (get-validator atom)]
-      (when validate
-        (try
-         (validate newval)
-         (catch Exception e
-           (throw (IllegalStateException. "Invalid atom state" e)))))
-      (.compareAndSet atom oldval newval)))
 

src/jvm/clojure/lang/ARef.java

@@ -0,0 +1,60 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
+ *   which can be found in the file CPL.TXT at the root of this distribution.
+ *   By using this software in any fashion, you are agreeing to be bound by
+ * 	 the terms of this license.
+ *   You must not remove this notice, or any other, from this software.
+ **/
+
+/* rich Jan 1, 2009 */
+
+package clojure.lang;
+
+public abstract class ARef extends AReference implements IRef {
+    private volatile IFn validator = null;
+
+    public ARef() {
+        super();
+    }
+
+    public ARef(IPersistentMap meta) {
+        super(meta);
+    }
+
+    void validate(IFn vf, Object val){
+        try{
+            if(vf != null && !RT.booleanCast(vf.invoke(val)))
+                throw new IllegalStateException("Invalid reference state");
+            }
+        catch(RuntimeException re)
+            {
+            throw re;
+            }
+        catch(Exception e)
+            {
+            throw new IllegalStateException("Invalid reference state", e);
+            }
+    }
+
+    void validate(Object val){
+        validate(validator,val);
+    }
+
+    public void setValidator(IFn vf){
+        try
+            {
+            validate(vf,get());
+            }
+        catch (Exception e)
+            {
+            throw new RuntimeException(e);
+            }
+        validator = vf;
+    }
+
+    public IFn getValidator(){
+        return validator;
+    }
+}

src/jvm/clojure/lang/AReference.java

@@ -0,0 +1,40 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
+ *   which can be found in the file CPL.TXT at the root of this distribution.
+ *   By using this software in any fashion, you are agreeing to be bound by
+ * 	 the terms of this license.
+ *   You must not remove this notice, or any other, from this software.
+ **/
+
+/* rich Dec 31, 2008 */
+
+package clojure.lang;
+
+public class AReference implements IReference {
+    private IPersistentMap _meta;
+
+    public AReference() {
+        this(null);
+    }
+
+    public AReference(IPersistentMap meta) {
+        _meta = meta;
+    }
+
+    synchronized public IPersistentMap meta() {
+        return _meta;
+    }
+
+    synchronized public IPersistentMap alterMeta(IFn alter, ISeq args) throws Exception {
+        _meta = (IPersistentMap) alter.applyTo(new Cons(_meta, args));
+        return _meta;
+    }
+
+    synchronized public IPersistentMap resetMeta(IPersistentMap m) {
+        _meta = m;
+        return m;
+    }
+
+}

src/jvm/clojure/lang/Agent.java

@@ -16,10 +16,9 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.Map;
 
-public class Agent implements IRef{
+public class Agent extends ARef {
 volatile Object state;
-volatile IFn validator = null;
-AtomicReference<IPersistentStack> q = new AtomicReference(PersistentQueue.EMPTY);
+    AtomicReference<IPersistentStack> q = new AtomicReference(PersistentQueue.EMPTY);
 AtomicReference<IPersistentMap> watchers = new AtomicReference(PersistentHashMap.EMPTY);
 
 volatile ISeq errors = null;
@@ -116,29 +115,18 @@ public Agent(Object state) throws Exception{
 	this(state,null);
 }
 
-public Agent(Object state, IFn validator) throws Exception{
-	this.validator = validator;
-	setState(state);
+public Agent(Object state, IPersistentMap meta) throws Exception {
+    super(meta);
+    setState(state);
 }
 
 boolean setState(Object newState) throws Exception{
-	validate(getValidator(),newState);
+	validate(newState);
 	boolean ret = state != newState;
 	state = newState;
 	return ret;
 }
 
-void validate(IFn vf, Object val){
-	try{
-		if(vf != null)
-			vf.invoke(val);
-		}
-	catch(Exception e)
-		{
-		throw new IllegalStateException("Invalid agent state", e);
-		}
-}
-
 public Object get() throws Exception{
 	if(errors != null)
 		{
@@ -147,16 +135,7 @@ public Object get() throws Exception{
 	return state;
 }
 
-public void setValidator(IFn vf){
-	validate(vf,state);
-	validator = vf;
-}
-
-public IFn getValidator(){
-	return validator;
-}
-
-public ISeq getErrors(){
+    public ISeq getErrors(){
 	return errors;
 }