clojure 1.0.0

data/src/jvm/clojure/lang/TransactionalHashMap.java

@@ -0,0 +1,197 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+ *   which can be found in the file epl-v10.html 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 Jul 31, 2008 */
+
+package clojure.lang;
+
+import java.util.concurrent.ConcurrentMap;
+import java.util.*;
+
+public class TransactionalHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>{
+final Ref[] bins;
+
+IPersistentMap mapAt(int bin){
+	return (IPersistentMap) bins[bin].deref();
+}
+
+final int binFor(Object k){
+	//spread hashes, a la Cliff Click
+	int h = k.hashCode();
+	h ^= (h >>> 20) ^ (h >>> 12);
+	h ^= (h >>> 7) ^ (h >>> 4);
+	return h % bins.length;
+//	return k.hashCode() % bins.length;
+}
+
+Entry entryAt(Object k){
+	return mapAt(binFor(k)).entryAt(k);
+}
+
+public TransactionalHashMap() throws Exception{
+	this(421);
+}
+
+public TransactionalHashMap(int nBins) throws Exception{
+	bins = new Ref[nBins];
+	for(int i = 0; i < nBins; i++)
+		bins[i] = new Ref(PersistentHashMap.EMPTY);
+}
+
+public TransactionalHashMap(Map<? extends K, ? extends V> m) throws Exception{
+	this(m.size());
+	putAll(m);
+}
+
+public int size(){
+	int n = 0;
+	for(int i = 0; i < bins.length; i++)
+		{
+		n += mapAt(i).count();
+		}
+	return n;
+}
+
+public boolean isEmpty(){
+	return size() == 0;
+}
+
+public boolean containsKey(Object k){
+	return entryAt(k) != null;
+}
+
+public V get(Object k){
+	Entry e = entryAt(k);
+	if(e != null)
+		return (V) e.getValue();
+	return null;
+}
+
+public V put(K k, V v){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Object ret = map.valAt(k);
+	r.set(map.assoc(k, v));
+	return (V) ret;
+}
+
+public V remove(Object k){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Object ret = map.valAt(k);
+	//checked exceptions are a bad idea, especially in an interface
+	try
+		{
+		r.set(map.without(k));
+		}
+	catch(Exception e)
+		{
+		throw new RuntimeException(e);
+		}
+	return (V) ret;
+}
+
+public void putAll(Map<? extends K, ? extends V> map){
+	for(Iterator i = map.entrySet().iterator(); i.hasNext();)
+		{
+		Entry<K, V> e = (Entry) i.next();
+		put(e.getKey(), e.getValue());
+		}
+}
+
+public void clear(){
+	for(int i = 0; i < bins.length; i++)
+		{
+		Ref r = bins[i];
+		IPersistentMap map = (IPersistentMap) r.deref();
+		if(map.count() > 0)
+			{
+			r.set(PersistentHashMap.EMPTY);
+			}
+		}
+}
+
+public Set<Entry<K, V>> entrySet(){
+	final ArrayList<Map.Entry<K, V>> entries = new ArrayList(bins.length);
+	for(int i = 0; i < bins.length; i++)
+		{
+		IPersistentMap map = mapAt(i);
+		if(map.count() > 0)
+			entries.addAll((Collection) RT.seq(map));
+		}
+	return new AbstractSet<Entry<K, V>>(){
+		public Iterator iterator(){
+			return Collections.unmodifiableList(entries).iterator();
+		}
+
+		public int size(){
+			return entries.size();
+		}
+	};
+}
+
+public V putIfAbsent(K k, V v){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Entry e = map.entryAt(k);
+	if(e == null)
+		{
+		r.set(map.assoc(k, v));
+		return null;
+		}
+	else
+		return (V) e.getValue();
+}
+
+public boolean remove(Object k, Object v){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Entry e = map.entryAt(k);
+	if(e != null && e.getValue().equals(v))
+		{
+		//checked exceptions are a bad idea, especially in an interface
+		try
+			{
+			r.set(map.without(k));
+			}
+		catch(Exception ex)
+			{
+			throw new RuntimeException(ex);
+			}
+		return true;
+		}
+	return false;
+}
+
+public boolean replace(K k, V oldv, V newv){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Entry e = map.entryAt(k);
+	if(e != null && e.getValue().equals(oldv))
+		{
+		r.set(map.assoc(k, newv));
+		return true;
+		}
+	return false;
+}
+
+public V replace(K k, V v){
+	Ref r = bins[binFor(k)];
+	IPersistentMap map = (IPersistentMap) r.deref();
+	Entry e = map.entryAt(k);
+	if(e != null)
+		{
+		r.set(map.assoc(k, v));
+		return (V) e.getValue();
+		}
+	return null;
+}
+
+}

data/src/jvm/clojure/lang/Util.java

@@ -0,0 +1,74 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+ *   which can be found in the file epl-v10.html 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 Apr 19, 2008 */
+
+package clojure.lang;
+
+import java.math.BigInteger;
+
+public class Util{
+static public boolean equiv(Object k1, Object k2){
+	if(k1 == k2)
+		return true;
+	if(k1 != null)
+		{
+		if(k1 instanceof Number)
+			return Numbers.equiv(k1, k2);
+		else if(k1 instanceof IPersistentCollection && k2 instanceof IPersistentCollection)
+			return ((IPersistentCollection)k1).equiv(k2);
+		return k1.equals(k2);
+		}
+	return false;
+}
+
+static public boolean equals(Object k1, Object k2){
+	if(k1 == k2)
+		return true;
+	return k1 != null && k1.equals(k2);
+}
+
+static public int compare(Object k1, Object k2){
+	if(k1 == k2)
+		return 0;
+	if(k1 != null)
+		{
+		if(k2 == null)
+			return 1;
+		if(k1 instanceof Number)
+			return Numbers.compare((Number) k1, (Number) k2);
+		return ((Comparable) k1).compareTo(k2);
+		}
+	return -1;
+}
+
+static public int hash(Object o){
+	if(o == null)
+		return 0;
+	return o.hashCode();
+}
+
+static public int hashCombine(int seed, int hash){
+	//a la boost
+	seed ^= hash + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+	return seed;
+}
+
+static public boolean isPrimitive(Class c){
+	return c != null && c.isPrimitive() && !(c == Void.TYPE);
+}
+
+static public boolean isInteger(Object x){
+	return x instanceof Integer
+			|| x instanceof Long
+			|| x instanceof BigInteger;
+}
+
+}

data/src/jvm/clojure/lang/Var.java

@@ -0,0 +1,472 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+ *   which can be found in the file epl-v10.html 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 Jul 31, 2007 */
+
+package clojure.lang;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+
+public final class Var extends ARef implements IFn, IRef, Settable{
+
+
+static class Frame{
+	//Var->Box
+	Associative bindings;
+	//Var->val
+	Associative frameBindings;
+	Frame prev;
+
+
+	public Frame(){
+		this(PersistentHashMap.EMPTY, PersistentHashMap.EMPTY, null);
+	}
+
+	public Frame(Associative frameBindings, Associative bindings, Frame prev){
+		this.frameBindings = frameBindings;
+		this.bindings = bindings;
+		this.prev = prev;
+	}
+}
+
+static ThreadLocal<Frame> dvals = new ThreadLocal<Frame>(){
+
+	protected Frame initialValue(){
+		return new Frame();
+	}
+};
+
+static Keyword privateKey = Keyword.intern(null, "private");
+static IPersistentMap privateMeta = new PersistentArrayMap(new Object[]{privateKey, Boolean.TRUE});
+static Keyword macroKey = Keyword.intern(null, "macro");
+static Keyword nameKey = Keyword.intern(null, "name");
+static Keyword nsKey = Keyword.intern(null, "ns");
+//static Keyword tagKey = Keyword.intern(null, "tag");
+
+volatile Object root;
+transient final AtomicInteger count;
+public final Symbol sym;
+public final Namespace ns;
+
+//IPersistentMap _meta;
+
+public static Var intern(Namespace ns, Symbol sym, Object root){
+	return intern(ns, sym, root, true);
+}
+
+public static Var intern(Namespace ns, Symbol sym, Object root, boolean replaceRoot){
+	Var dvout = ns.intern(sym);
+	if(!dvout.hasRoot() || replaceRoot)
+		dvout.bindRoot(root);
+	return dvout;
+}
+
+
+public String toString(){
+	if(ns != null)
+		return "#'" + ns.name + "/" + sym;
+	return "#<Var: " + (sym != null ? sym.toString() : "--unnamed--") + ">";
+}
+
+public static Var find(Symbol nsQualifiedSym){
+	if(nsQualifiedSym.ns == null)
+		throw new IllegalArgumentException("Symbol must be namespace-qualified");
+	Namespace ns = Namespace.find(Symbol.create(nsQualifiedSym.ns));
+	if(ns == null)
+		throw new IllegalArgumentException("No such namespace: " + nsQualifiedSym.ns);
+	return ns.findInternedVar(Symbol.create(nsQualifiedSym.name));
+}
+
+public static Var intern(Symbol nsName, Symbol sym){
+	Namespace ns = Namespace.findOrCreate(nsName);
+	return intern(ns, sym);
+}
+
+public static Var internPrivate(String nsName, String sym){
+	Namespace ns = Namespace.findOrCreate(Symbol.intern(nsName));
+	Var ret = intern(ns, Symbol.intern(sym));
+	ret.setMeta(privateMeta);
+	return ret;
+}
+
+public static Var intern(Namespace ns, Symbol sym){
+	return ns.intern(sym);
+}
+
+
+public static Var create(){
+	return new Var(null, null);
+}
+
+public static Var create(Object root){
+	return new Var(null, null, root);
+}
+
+Var(Namespace ns, Symbol sym){
+	this.ns = ns;
+	this.sym = sym;
+	this.count = new AtomicInteger();
+	this.root = dvals;  //use dvals as magic not-bound value
+	setMeta(PersistentHashMap.EMPTY);
+}
+
+Var(Namespace ns, Symbol sym, Object root){
+	this(ns, sym);
+	this.root = root;
+}
+
+public boolean isBound(){
+	return hasRoot() || (count.get() > 0 && dvals.get().bindings.containsKey(this));
+}
+
+final public Object get(){
+	return deref();
+}
+
+final public Object deref(){
+	Box b = getThreadBinding();
+	if(b != null)
+		return b.val;
+	if(hasRoot())
+		return root;
+	throw new IllegalStateException(String.format("Var %s/%s is unbound.", ns, sym));
+}
+
+public void setValidator(IFn vf){
+	if(hasRoot())
+		validate(vf, getRoot());
+	validator = vf;
+}
+
+public Object alter(IFn fn, ISeq args) throws Exception{
+	set(fn.applyTo(RT.cons(deref(), args)));
+	return this;
+}
+
+public Object set(Object val){
+	validate(getValidator(), val);
+	Box b = getThreadBinding();
+	if(b != null)
+		return (b.val = val);
+	//jury still out on this
+//	if(hasRoot())
+//		{
+//		bindRoot(val);
+//		return val;
+//		}
+	throw new IllegalStateException(String.format("Can't change/establish root binding of: %s with set", sym));
+}
+
+public Object doSet(Object val) throws Exception {
+    return set(val);
+    }
+
+public Object doReset(Object val) throws Exception {
+    bindRoot(val);
+    return val;
+    }
+
+public void setMeta(IPersistentMap m) {
+    //ensure these basis keys
+    resetMeta(m.assoc(nameKey, sym).assoc(nsKey, ns));
+}
+
+public void setMacro() {
+    try
+        {
+        alterMeta(assoc, RT.list(macroKey, RT.T));
+        }
+    catch (Exception e)
+        {
+        throw new RuntimeException(e);
+        }
+}
+
+public boolean isMacro(){
+	return RT.booleanCast(meta().valAt(macroKey));
+}
+
+//public void setExported(boolean state){
+//	_meta = _meta.assoc(privateKey, state);
+//}
+
+public boolean isPublic(){
+	return !RT.booleanCast(meta().valAt(privateKey));
+}
+
+public Object getRoot(){
+	if(hasRoot())
+		return root;
+	throw new IllegalStateException(String.format("Var %s/%s is unbound.", ns, sym));
+}
+
+public Object getTag(){
+	return meta().valAt(RT.TAG_KEY);
+}
+
+public void setTag(Symbol tag) {
+    try
+        {
+        alterMeta(assoc, RT.list(RT.TAG_KEY, tag));
+        }
+    catch (Exception e)
+        {
+        throw new RuntimeException(e);
+        }
+}
+
+final public boolean hasRoot(){
+	return root != dvals;
+}
+
+//binding root always clears macro flag
+synchronized public void bindRoot(Object root){
+	validate(getValidator(), root);
+	Object oldroot = hasRoot()?this.root:null;
+	this.root = root;
+    try
+        {
+        alterMeta(assoc, RT.list(macroKey, RT.F));
+        }
+    catch (Exception e)
+        {
+        throw new RuntimeException(e);
+        }
+    notifyWatches(oldroot,this.root);
+}
+
+synchronized void swapRoot(Object root){
+	validate(getValidator(), root);
+	Object oldroot = hasRoot()?this.root:null;
+	this.root = root;
+    notifyWatches(oldroot,root);
+}
+
+synchronized public void unbindRoot(){
+	this.root = dvals;
+}
+
+synchronized public void commuteRoot(IFn fn) throws Exception{
+	Object newRoot = fn.invoke(root);
+	validate(getValidator(), newRoot);
+	Object oldroot = getRoot();
+	this.root = newRoot;
+    notifyWatches(oldroot,newRoot);
+}
+
+synchronized public Object alterRoot(IFn fn, ISeq args) throws Exception{
+	Object newRoot = fn.applyTo(RT.cons(root, args));
+	validate(getValidator(), newRoot);
+	Object oldroot = getRoot();
+	this.root = newRoot;
+    notifyWatches(oldroot,newRoot);
+	return newRoot;
+}
+
+public static void pushThreadBindings(Associative bindings){
+	Frame f = dvals.get();
+	Associative bmap = f.bindings;
+	for(ISeq bs = bindings.seq(); bs != null; bs = bs.next())
+		{
+		IMapEntry e = (IMapEntry) bs.first();
+		Var v = (Var) e.key();
+		v.validate(v.getValidator(), e.val());
+		v.count.incrementAndGet();
+		bmap = bmap.assoc(v, new Box(e.val()));
+		}
+	dvals.set(new Frame(bindings, bmap, f));
+}
+
+public static void popThreadBindings(){
+	Frame f = dvals.get();
+	if(f.prev == null)
+		throw new IllegalStateException("Pop without matching push");
+	for(ISeq bs = RT.keys(f.frameBindings); bs != null; bs = bs.next())
+		{
+		Var v = (Var) bs.first();
+		v.count.decrementAndGet();
+		}
+	dvals.set(f.prev);
+}
+
+public static void releaseThreadBindings(){
+	Frame f = dvals.get();
+	if(f.prev == null)
+		throw new IllegalStateException("Release without full unwind");
+	for(ISeq bs = RT.keys(f.bindings); bs != null; bs = bs.next())
+		{
+		Var v = (Var) bs.first();
+		v.count.decrementAndGet();
+		}
+	dvals.set(null);
+}
+
+final Box getThreadBinding(){
+	if(count.get() > 0)
+		{
+		IMapEntry e = dvals.get().bindings.entryAt(this);
+		if(e != null)
+			return (Box) e.val();
+		}
+	return null;
+}
+
+final public IFn fn(){
+	return (IFn) deref();
+}
+
+public Object call() throws Exception{
+	return invoke();
+}
+
+public void run(){
+	try
+		{
+		invoke();
+		}
+	catch(Exception e)
+		{
+		throw new RuntimeException(e);
+		}
+}
+
+public Object invoke() throws Exception{
+	return fn().invoke();
+}
+
+public Object invoke(Object arg1) throws Exception{
+	return fn().invoke(arg1);
+}
+
+public Object invoke(Object arg1, Object arg2) throws Exception{
+	return fn().invoke(arg1, arg2);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3) throws Exception{
+	return fn().invoke(arg1, arg2, arg3);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7)
+		throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13)
+		throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14)
+		throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16, Object arg17) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16, arg17);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16, Object arg17, Object arg18) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16, arg17, arg18);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16, Object arg17, Object arg18, Object arg19) throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16, arg17, arg18, arg19);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16, Object arg17, Object arg18, Object arg19, Object arg20)
+		throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16, arg17, arg18, arg19, arg20);
+}
+
+public Object invoke(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7,
+                     Object arg8, Object arg9, Object arg10, Object arg11, Object arg12, Object arg13, Object arg14,
+                     Object arg15, Object arg16, Object arg17, Object arg18, Object arg19, Object arg20,
+                     Object... args)
+		throws Exception{
+	return fn().invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
+	                   arg16, arg17, arg18, arg19, arg20, args);
+}
+
+public Object applyTo(ISeq arglist) throws Exception{
+	return AFn.applyToHelper(this, arglist);
+}
+
+static IFn assoc = new AFn(){
+    @Override
+    public Object invoke(Object m, Object k, Object v) throws Exception {
+        return RT.assoc(m, k, v);
+    }
+};
+}