clojure 1.0.0

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

@@ -0,0 +1,72 @@
+/**
+ *   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 Mar 3, 2008 */
+
+package clojure.lang;
+
+import java.util.List;
+
+public class PersistentHashSet extends APersistentSet{
+
+static public final PersistentHashSet EMPTY = new PersistentHashSet(null, PersistentHashMap.EMPTY);
+
+public static PersistentHashSet create(Object... init){
+	PersistentHashSet ret = EMPTY;
+	for(int i = 0; i < init.length; i++)
+		{
+		ret = (PersistentHashSet) ret.cons(init[i]);
+		}
+	return ret;
+}
+
+public static PersistentHashSet create(List init){
+	PersistentHashSet ret = EMPTY;
+	for(Object key : init)
+		{
+		ret = (PersistentHashSet) ret.cons(key);
+		}
+	return ret;
+}
+
+static public PersistentHashSet create(ISeq items){
+	PersistentHashSet ret = EMPTY;
+	for(; items != null; items = items.next())
+		{
+		ret = (PersistentHashSet) ret.cons(items.first());
+		}
+	return ret;
+}
+
+PersistentHashSet(IPersistentMap meta, IPersistentMap impl){
+	super(meta, impl);
+}
+
+public IPersistentSet disjoin(Object key) throws Exception{
+	if(contains(key))
+		return new PersistentHashSet(meta(),impl.without(key));
+	return this;
+}
+
+public IPersistentSet cons(Object o){
+	if(contains(o))
+		return this;
+	return new PersistentHashSet(meta(),impl.assoc(o,o));
+}
+
+public IPersistentCollection empty(){
+	return EMPTY.withMeta(meta());	
+}
+
+public PersistentHashSet withMeta(IPersistentMap meta){
+	return new PersistentHashSet(meta, impl);
+}
+
+}

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

@@ -0,0 +1,298 @@
+/**
+ *   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.
+ **/
+
+package clojure.lang;
+
+import java.util.*;
+
+public class PersistentList extends ASeq implements IPersistentList, IReduce, List, Counted{
+
+private final Object _first;
+private final IPersistentList _rest;
+private final int _count;
+
+public static IFn creator = new RestFn(0){
+	protected Object doInvoke(Object args) throws Exception{
+		if(args instanceof ArraySeq)
+			{
+			Object[] argsarray = (Object[]) ((ArraySeq) args).array;
+			IPersistentList ret = EMPTY;
+			for(int i = argsarray.length - 1; i >= 0; --i)
+				ret = (IPersistentList) ret.cons(argsarray[i]);
+			return ret;
+			}
+		LinkedList list = new LinkedList();
+		for(ISeq s = RT.seq(args); s != null; s = s.next())
+			list.add(s.first());
+		return create(list);
+	}
+};
+
+final public static EmptyList EMPTY = new EmptyList(null);
+
+public PersistentList(Object first){
+	this._first = first;
+	this._rest = null;
+
+	this._count = 1;
+}
+
+PersistentList(IPersistentMap meta, Object _first, IPersistentList _rest, int _count){
+	super(meta);
+	this._first = _first;
+	this._rest = _rest;
+	this._count = _count;
+}
+
+public static IPersistentList create(List init){
+	IPersistentList ret = EMPTY;
+	for(ListIterator i = init.listIterator(init.size()); i.hasPrevious();)
+		{
+		ret = (IPersistentList) ret.cons(i.previous());
+		}
+	return ret;
+}
+
+public Object first(){
+	return _first;
+}
+
+public ISeq next(){
+	if(_count == 1)
+		return null;
+	return (ISeq) _rest;
+}
+
+public Object peek(){
+	return first();
+}
+
+public IPersistentList pop(){
+	if(_rest == null)
+		return EMPTY.withMeta(_meta);
+	return _rest;
+}
+
+public int count(){
+	return _count;
+}
+
+public PersistentList cons(Object o){
+	return new PersistentList(meta(), o, this, _count + 1);
+}
+
+public IPersistentCollection empty(){
+	return EMPTY.withMeta(meta());
+}
+
+public PersistentList withMeta(IPersistentMap meta){
+	if(meta != _meta)
+		return new PersistentList(meta, _first, _rest, _count);
+	return this;
+}
+
+public Object reduce(IFn f) throws Exception{
+	Object ret = first();
+	for(ISeq s = next(); s != null; s = s.next())
+		ret = f.invoke(ret, s.first());
+	return ret;
+}
+
+public Object reduce(IFn f, Object start) throws Exception{
+	Object ret = f.invoke(start, first());
+	for(ISeq s = next(); s != null; s = s.next())
+		ret = f.invoke(ret, s.first());
+	return ret;
+}
+
+
+    static class EmptyList extends Obj implements IPersistentList, List, ISeq, Counted{
+
+	public int hashCode(){
+		return 1;
+	}
+
+    public boolean equals(Object o) {
+        return (o instanceof Sequential || o instanceof List) && RT.seq(o) == null;
+    }
+
+	public boolean equiv(Object o){
+		return equals(o);
+	}
+	
+    EmptyList(IPersistentMap meta){
+		super(meta);
+	}
+
+        public Object first() {
+            return null;
+        }
+
+        public ISeq next() {
+            return null;
+        }
+
+        public ISeq more() {
+            return this;
+        }
+
+        public PersistentList cons(Object o){
+		return new PersistentList(meta(), o, null, 1);
+	}
+
+	public IPersistentCollection empty(){
+		return this;
+	}
+
+	public EmptyList withMeta(IPersistentMap meta){
+		if(meta != meta())
+			return new EmptyList(meta);
+		return this;
+	}
+
+	public Object peek(){
+		return null;
+	}
+
+	public IPersistentList pop(){
+		throw new IllegalStateException("Can't pop empty list");
+	}
+
+	public int count(){
+		return 0;
+	}
+
+	public ISeq seq(){
+		return null;
+	}
+
+
+	public int size(){
+		return 0;
+	}
+
+	public boolean isEmpty(){
+		return true;
+	}
+
+	public boolean contains(Object o){
+		return false;
+	}
+
+	public Iterator iterator(){
+		return new Iterator(){
+
+			public boolean hasNext(){
+				return false;
+			}
+
+			public Object next(){
+				throw new NoSuchElementException();
+			}
+
+			public void remove(){
+				throw new UnsupportedOperationException();
+			}
+		};
+	}
+
+	public Object[] toArray(){
+		return RT.EMPTY_ARRAY;
+	}
+
+	public boolean add(Object o){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean remove(Object o){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean addAll(Collection collection){
+		throw new UnsupportedOperationException();
+	}
+
+	public void clear(){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean retainAll(Collection collection){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean removeAll(Collection collection){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean containsAll(Collection collection){
+		return collection.isEmpty();
+	}
+
+	public Object[] toArray(Object[] objects){
+		if(objects.length > 0)
+			objects[0] = null;
+		return objects;
+	}
+
+	//////////// List stuff /////////////////
+	private List reify(){
+		return Collections.unmodifiableList(new ArrayList(this));
+	}
+
+	public List subList(int fromIndex, int toIndex){
+		return reify().subList(fromIndex, toIndex);
+	}
+
+	public Object set(int index, Object element){
+		throw new UnsupportedOperationException();
+	}
+
+	public Object remove(int index){
+		throw new UnsupportedOperationException();
+	}
+
+	public int indexOf(Object o){
+		ISeq s = seq();
+		for(int i = 0; s != null; s = s.next(), i++)
+			{
+			if(Util.equiv(s.first(), o))
+				return i;
+			}
+		return -1;
+	}
+
+	public int lastIndexOf(Object o){
+		return reify().lastIndexOf(o);
+	}
+
+	public ListIterator listIterator(){
+		return reify().listIterator();
+	}
+
+	public ListIterator listIterator(int index){
+		return reify().listIterator(index);
+	}
+
+	public Object get(int index){
+		return RT.nth(this, index);
+	}
+
+	public void add(int index, Object element){
+		throw new UnsupportedOperationException();
+	}
+
+	public boolean addAll(int index, Collection c){
+		throw new UnsupportedOperationException();
+	}
+
+
+}
+
+}

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

@@ -0,0 +1,304 @@
+/**
+ *   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.
+ **/
+
+package clojure.lang;
+
+import java.util.Collection;
+import java.util.Iterator;
+//import java.util.concurrent.ConcurrentLinkedQueue;
+
+/**
+ * conses onto rear, peeks/pops from front
+ * See Okasaki's Batched Queues
+ * This differs in that it uses a PersistentArrayList as the rear, which is in-order,
+ * so no reversing or suspensions required for persistent use
+ */
+
+public class PersistentQueue extends Obj implements IPersistentList, Collection{
+
+final public static PersistentQueue EMPTY = new PersistentQueue(null, null, null);
+
+//*
+final ISeq f;
+final PersistentVector r;
+//static final int INITIAL_REAR_SIZE = 4;
+int _hash = -1;
+
+PersistentQueue(IPersistentMap meta, ISeq f, PersistentVector r){
+	super(meta);
+	this.f = f;
+	this.r = r;
+}
+
+public boolean equiv(Object obj){
+
+	if(!(obj instanceof Sequential))
+		return false;
+	ISeq ms = RT.seq(obj);
+	for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
+		{
+		if(ms == null || !Util.equiv(s.first(), ms.first()))
+			return false;
+		}
+	return ms.next() == null;
+
+}
+
+public boolean equals(Object obj){
+
+	if(!(obj instanceof Sequential))
+		return false;
+	ISeq ms = RT.seq(obj);
+	for(ISeq s = seq(); s != null; s = s.next(), ms = ms.next())
+		{
+		if(ms == null || !Util.equals(s.first(), ms.first()))
+			return false;
+		}
+	return ms.next() == null;
+
+}
+
+public int hashCode(){
+	if(_hash == -1)
+		{
+		int hash = 0;
+		for(ISeq s = seq(); s != null; s = s.next())
+			{
+			hash = Util.hashCombine(hash, Util.hash(s.first()));
+			}
+		this._hash = hash;
+		}
+	return _hash;
+}
+
+public Object peek(){
+	return RT.first(f);
+}
+
+public PersistentQueue pop(){
+	if(f == null)  //hmmm... pop of empty queue -> empty queue?
+		return this;
+	//throw new IllegalStateException("popping empty queue");
+	ISeq f1 = f.next();
+	PersistentVector r1 = r;
+	if(f1 == null)
+		{
+		f1 = RT.seq(r);
+		r1 = null;
+		}
+	return new PersistentQueue(meta(), f1, r1);
+}
+
+public int count(){
+	return RT.count(f) + RT.count(r);
+}
+
+public ISeq seq(){
+	if(f == null)
+		return null;
+	return new Seq(f, RT.seq(r));
+}
+
+public PersistentQueue cons(Object o){
+	if(f == null)     //empty
+		return new PersistentQueue(meta(), RT.list(o), null);
+	else
+		return new PersistentQueue(meta(), f, (r != null ? r : PersistentVector.EMPTY).cons(o));
+}
+
+public IPersistentCollection empty(){
+	return EMPTY.withMeta(meta());	
+}
+
+public PersistentQueue withMeta(IPersistentMap meta){
+	return new PersistentQueue(meta, f, r);
+}
+
+static class Seq extends ASeq{
+	final ISeq f;
+	final ISeq rseq;
+
+	Seq(ISeq f, ISeq rseq){
+		this.f = f;
+		this.rseq = rseq;
+	}
+
+	Seq(IPersistentMap meta, ISeq f, ISeq rseq){
+		super(meta);
+		this.f = f;
+		this.rseq = rseq;
+	}
+
+	public Object first(){
+		return f.first();
+	}
+
+	public ISeq next(){
+		ISeq f1 = f.next();
+		ISeq r1 = rseq;
+		if(f1 == null)
+			{
+			if(rseq == null)
+				return null;
+			f1 = rseq;
+			r1 = null;
+			}
+		return new Seq(f1, r1);
+	}
+
+	public int count(){
+		return RT.count(f) + RT.count(rseq);
+	}
+
+	public Seq withMeta(IPersistentMap meta){
+		return new Seq(meta, f, rseq);
+	}
+}
+
+// java.util.Collection implementation
+
+public Object[] toArray(){
+	return RT.seqToArray(seq());
+}
+
+public boolean add(Object o){
+	throw new UnsupportedOperationException();
+}
+
+public boolean remove(Object o){
+	throw new UnsupportedOperationException();
+}
+
+public boolean addAll(Collection c){
+	throw new UnsupportedOperationException();
+}
+
+public void clear(){
+	throw new UnsupportedOperationException();
+}
+
+public boolean retainAll(Collection c){
+	throw new UnsupportedOperationException();
+}
+
+public boolean removeAll(Collection c){
+	throw new UnsupportedOperationException();
+}
+
+public boolean containsAll(Collection c){
+	for(Object o : c)
+		{
+		if(contains(o))
+			return true;
+		}
+	return false;
+}
+
+public Object[] toArray(Object[] a){
+	if(a.length >= count())
+		{
+		ISeq s = seq();
+		for(int i = 0; s != null; ++i, s = s.next())
+			{
+			a[i] = s.first();
+			}
+		if(a.length >= count())
+			a[count()] = null;
+		return a;
+		}
+	else
+		return toArray();
+}
+
+public int size(){
+	return count();
+}
+
+public boolean isEmpty(){
+	return count() == 0;
+}
+
+public boolean contains(Object o){
+	for(ISeq s = seq(); s != null; s = s.next())
+		{
+		if(Util.equiv(s.first(), o))
+			return true;
+		}
+	return false;
+}
+
+public Iterator iterator(){
+	return new SeqIterator(seq());
+}
+
+/*
+public static void main(String[] args){
+	if(args.length != 1)
+		{
+		System.err.println("Usage: PersistentQueue n");
+		return;
+		}
+	int n = Integer.parseInt(args[0]);
+
+
+	long startTime, estimatedTime;
+
+	Queue list = new LinkedList();
+	//Queue list = new ConcurrentLinkedQueue();
+	System.out.println("Queue");
+	startTime = System.nanoTime();
+	for(int i = 0; i < n; i++)
+		{
+		list.add(i);
+		list.add(i);
+		list.remove();
+		}
+	for(int i = 0; i < n - 10; i++)
+		{
+		list.remove();
+		}
+	estimatedTime = System.nanoTime() - startTime;
+	System.out.println("time: " + estimatedTime / 1000000);
+	System.out.println("peek: " + list.peek());
+
+
+	PersistentQueue q = PersistentQueue.EMPTY;
+	System.out.println("PersistentQueue");
+	startTime = System.nanoTime();
+	for(int i = 0; i < n; i++)
+		{
+		q = q.cons(i);
+		q = q.cons(i);
+		q = q.pop();
+		}
+//    IPersistentList lastq = null;
+//    IPersistentList lastq2;
+	for(int i = 0; i < n - 10; i++)
+		{
+		//lastq2 = lastq;
+		//lastq = q;
+		q = q.pop();
+		}
+	estimatedTime = System.nanoTime() - startTime;
+	System.out.println("time: " + estimatedTime / 1000000);
+	System.out.println("peek: " + q.peek());
+
+	IPersistentList q2 = q;
+	for(int i = 0; i < 10; i++)
+		{
+		q2 = (IPersistentList) q2.cons(i);
+		}
+//    for(ISeq s = q.seq();s != null;s = s.rest())
+//        System.out.println("q: " + s.first().toString());
+//    for(ISeq s = q2.seq();s != null;s = s.rest())
+//        System.out.println("q2: " + s.first().toString());
+}
+*/
+}