renamed persistent data structures

10 files changed, 147 insertions, 147 deletions

diff --git a/src/org/clojure/runtime/IMap.java b/src/org/clojure/runtime/IPersistentMap.java
index 015df00d..aff5f8a0 100644
--- a/src/org/clojure/runtime/IMap.java
+++ b/src/org/clojure/runtime/IPersistentMap.java
@@ -11,7 +11,7 @@
 package org.clojure.runtime;

 

 

-public interface IMap extends Iterable {

+public interface IPersistentMap extends Iterable {

 

 int count();

 

@@ -19,11 +19,11 @@ boolean contains(Object key);
 

 IMapEntry find(Object key);

 

-IMap add(Object key);

+IPersistentMap add(Object key);

 

-IMap put(Object key, Object val);

+IPersistentMap put(Object key, Object val);

 

-IMap remove(Object key);

+IPersistentMap remove(Object key);

 

 Object get(Object key);

 

diff --git a/src/org/clojure/runtime/IdentityHashtableMap.java b/src/org/clojure/runtime/IdentityHashtableMap.java
deleted file mode 100644
index 71d93eeb..00000000
--- a/src/org/clojure/runtime/IdentityHashtableMap.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/**

- *   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.

- **/

-

-package org.clojure.runtime;

-

-public class IdentityHashtableMap extends HashtableMap{

-

-public IdentityHashtableMap(int initialCapacity) {

-    super(initialCapacity);

-}

-

-public IdentityHashtableMap(Object[] init) {

-    super(init);

-}

-

-IdentityHashtableMap(int count, PersistentArray array) {

-    super(count, array);

-}

-

-IMap create(int capacity) {

-    return new IdentityHashtableMap(capacity);

-}

-

-IMap create(int count, PersistentArray array) {

-    return new IdentityHashtableMap(count, array);

-}

-

-IMap createArrayMap(Object[] init) {

-    return new IdentityArrayMap(init);

-}

-}

diff --git a/src/org/clojure/runtime/ArrayMap.java b/src/org/clojure/runtime/PersistentArrayMap.java
index 49dec167..5d7b8171 100644
--- a/src/org/clojure/runtime/ArrayMap.java
+++ b/src/org/clojure/runtime/PersistentArrayMap.java
@@ -23,11 +23,11 @@ import java.util.Iterator;
  * null keys and values are ok, but you won't be able to distinguish a null value via get - use contains/find

  */

 

-public class ArrayMap implements IMap {

+public class PersistentArrayMap implements IPersistentMap {

 

 final Object[] array;

 

-public ArrayMap(){

+public PersistentArrayMap(){

     this.array = RT.EMPTY_ARRAY;

 }

 

@@ -35,7 +35,7 @@ public ArrayMap(){
  * This ctor captures/aliases the passed array, so do not modify later

  * @param init {key1,val1,key2,val2,...}

  */

-public ArrayMap(Object[] init){

+public PersistentArrayMap(Object[] init){

     this.array = init;

 }

 

@@ -54,12 +54,12 @@ public IMapEntry find(Object key) {
     return null;

 }

 

-public IMap add(Object key) {

+public IPersistentMap add(Object key) {

 

     return put(key,null);

 }

 

-public IMap put(Object key, Object val) {

+public IPersistentMap put(Object key, Object val) {

     int i = indexOf(key);

     Object[] newArray;

     if(i >= 0) //already have key, same-sized replacement

@@ -77,10 +77,10 @@ public IMap put(Object key, Object val) {
         newArray[0] = key;

         newArray[1] = val;

         }

-    return new ArrayMap(newArray);

+    return new PersistentArrayMap(newArray);

 }

 

-public IMap remove(Object key) {

+public IPersistentMap remove(Object key) {

     int i = indexOf(key);

     if(i >= 0) //have key, will remove

         {

@@ -94,7 +94,7 @@ public IMap remove(Object key) {
                 d += 2;

                 }

             }

-        return new ArrayMap(newArray);

+        return new PersistentArrayMap(newArray);

         }

     //don't have key, no op

     return this;

diff --git a/src/org/clojure/runtime/HashtableMap.java b/src/org/clojure/runtime/PersistentHashtableMap.java
index a96a9761..7047afa3 100644
--- a/src/org/clojure/runtime/HashtableMap.java
+++ b/src/org/clojure/runtime/PersistentHashtableMap.java
@@ -13,7 +13,7 @@ package org.clojure.runtime;
 import java.util.Iterator;

 import java.math.BigInteger;

 

-public class HashtableMap implements IMap, Iterable {

+public class PersistentHashtableMap implements IPersistentMap {

 

 static final float FILL_FACTOR = 0.75f;

 

@@ -21,7 +21,7 @@ final PersistentArray array;
 final int _count;

 final int growAtCount;

 

-public HashtableMap(int initialCapacity) {

+public PersistentHashtableMap(int initialCapacity) {

     array = new PersistentArray(calcPrimeCapacity(initialCapacity));

     _count = 0;

     this.growAtCount = (int) (this.array.length()*FILL_FACTOR);

@@ -30,7 +30,7 @@ public HashtableMap(int initialCapacity) {
 /**

  * @param init {key1,val1,key2,val2,...}

  */

-public HashtableMap(Object[] init){

+public PersistentHashtableMap(Object[] init){

     //start halfway to a rehash

     PersistentArray narray = new PersistentArray(calcPrimeCapacity(init.length));

     for(int i=0;i<init.length;i+=2)

@@ -42,13 +42,13 @@ public HashtableMap(Object[] init){
     this.growAtCount = (int) (this.array.length()*FILL_FACTOR);

 }

 

-HashtableMap(int count,PersistentArray array) {

+PersistentHashtableMap(int count,PersistentArray array) {

     this._count = count;

     this.array = array;

     this.growAtCount = (int) (this.array.length()*FILL_FACTOR);

 }

 

-HashtableMap(int count,PersistentArray array,int growAt) {

+PersistentHashtableMap(int count,PersistentArray array,int growAt) {

     this._count = count;

     this.array = array;

     this.growAtCount = growAt;

@@ -63,22 +63,22 @@ public int count() {
 }

 

 public boolean contains(Object key) {

-    IMap entries = entriesFor(key);

+    IPersistentMap entries = entriesFor(key);

     return entries != null && entries.contains(key);

 }

 

 public IMapEntry find(Object key) {

-    IMap entries = entriesFor(key);

+    IPersistentMap entries = entriesFor(key);

     if(entries != null)

         return entries.find(key);

     return null;

 }

 

-public IMap add(Object key) {

+public IPersistentMap add(Object key) {

     return put(key, null);

 }

 

-public IMap put(Object key, Object val) {

+public IPersistentMap put(Object key, Object val) {

     if(_count > growAtCount)

         return grow().put(key, val);

     int i = bucketFor(key,array);

@@ -86,14 +86,14 @@ public IMap put(Object key, Object val) {
     PersistentArray newArray = doPut(i, key, val, array);

     if(newArray == array)

         return this;

-    if(array.get(i) != null && ((IMap)newArray.get(i)).count() == ((IMap)array.get(i)).count()) //key already there, no growth

+    if(array.get(i) != null && ((IPersistentMap)newArray.get(i)).count() == ((IPersistentMap)array.get(i)).count()) //key already there, no growth

         incr = 0;

     return create(_count + incr, newArray, growAtCount);

 }

 

 PersistentArray doPut(int i,Object key,Object val,PersistentArray array){

-    IMap entries = (IMap) array.get(i);

-    IMap newEntries;

+    IPersistentMap entries = (IPersistentMap) array.get(i);

+    IPersistentMap newEntries;

     if (entries != null)

         {

         newEntries = entries.put(key, val);

@@ -107,12 +107,12 @@ PersistentArray doPut(int i,Object key,Object val,PersistentArray array){
     return array.set(i, newEntries);

 }

 

-public IMap remove(Object key) {

+public IPersistentMap remove(Object key) {

     int i = bucketFor(key,array);

-    IMap entries = (IMap) array.get(i);

+    IPersistentMap entries = (IPersistentMap) array.get(i);

     if (entries != null)

         {

-        IMap newEntries = entries.remove(key);

+        IPersistentMap newEntries = entries.remove(key);

         if (newEntries != entries)

             return create(_count - 1, array.set(i, newEntries));

         }

@@ -121,7 +121,7 @@ public IMap remove(Object key) {
 }

 

 public Object get(Object key) {

-    IMap entries = entriesFor(key);

+    IPersistentMap entries = entriesFor(key);

     if(entries != null)

         return entries.get(key);

     return null;

@@ -136,7 +136,7 @@ public Iterator<IMapEntry> iterator() {
 }

 

 

-IMap grow(){

+IPersistentMap grow(){

     PersistentArray newArray = new PersistentArray(calcPrimeCapacity(_count * 2));

     for (Object o : this)

         {

@@ -210,7 +210,7 @@ static class Iter implements Iterator, IMapEntry{
 static class Iter implements Iterator{

 	PersistentArray buckets;

 	int b;

-	ListMap e;

+	PersistentListMap e;

 

 	Iter(PersistentArray buckets){

         this.buckets = buckets;

@@ -222,8 +222,8 @@ static class Iter implements Iterator{
         e = null;

         for(b = b+1;b<buckets.length();b++)

             {

-            ListMap a = (ListMap) buckets.get(b);

-            if(a != null && a != ListMap.EMPTY)

+            PersistentListMap a = (PersistentListMap) buckets.get(b);

+            if(a != null && a != PersistentListMap.EMPTY)

                 {

                 e = a;

                 break;

@@ -236,9 +236,9 @@ static class Iter implements Iterator{
     }

 

 	public Object next() {

-		ListMap ret = e;

+		PersistentListMap ret = e;

         e = e.rest();

-        if(e == ListMap.EMPTY)

+        if(e == PersistentListMap.EMPTY)

             nextBucket();

         return ret;

     }

@@ -248,33 +248,33 @@ static class Iter implements Iterator{
     }

 }

 

-final IMap entriesFor(Object key){

-    return (IMap) array.get(bucketFor(key,array));

+final IPersistentMap entriesFor(Object key){

+    return (IPersistentMap) array.get(bucketFor(key,array));

 }

 

 static int bucketFor(Object key, PersistentArray array) {

     return (key.hashCode() & 0x7fffffff)%array.length();

 }

 

-IMap create(int capacity) {

-    return new HashtableMap(capacity);

+IPersistentMap create(int capacity) {

+    return new PersistentHashtableMap(capacity);

 }

 

-IMap create(int count,PersistentArray array) {

-    return new HashtableMap(count, array);

+IPersistentMap create(int count,PersistentArray array) {

+    return new PersistentHashtableMap(count, array);

 }

 

-private IMap create(int i, PersistentArray newArray, int growAtCount){

-	return new HashtableMap(i, newArray, growAtCount);

+private IPersistentMap create(int i, PersistentArray newArray, int growAtCount){

+	return new PersistentHashtableMap(i, newArray, growAtCount);

 }

 

 

-IMap createArrayMap(Object[] init) {

-    return new ArrayMap(init);

+IPersistentMap createArrayMap(Object[] init) {

+    return new PersistentArrayMap(init);

 }

 

-private IMap createListMap(Object key, Object val){

-	return ListMap.create(key,val);

+private IPersistentMap createListMap(Object key, Object val){

+	return PersistentListMap.create(key,val);

 }

 

 }

diff --git a/src/org/clojure/runtime/PersistentHashMap.java b/src/org/clojure/runtime/PersistentHybridMap.java
index f4ac6330..215b13c0 100644
--- a/src/org/clojure/runtime/PersistentHashMap.java
+++ b/src/org/clojure/runtime/PersistentHybridMap.java
@@ -12,25 +12,25 @@ package org.clojure.runtime;
 

 import java.util.Iterator;

 

-public class PersistentHashMap implements IMap, Iterable{

+public class PersistentHybridMap implements IPersistentMap{

 

-IMap impl;

+IPersistentMap impl;

 static final int CAPACITY_THRESHOLD = 42;

 

-public PersistentHashMap(Object[] init){

+public PersistentHybridMap(Object[] init){

     if(init.length/2 < CAPACITY_THRESHOLD)

         impl = createArrayMap(init);

     impl = createHashtableMap(init);

 }

 

-public PersistentHashMap(int initialCapacity){

+public PersistentHybridMap(int initialCapacity){

     if(initialCapacity < CAPACITY_THRESHOLD)

         impl = createArrayMap();

 	else

         impl = createHashtableMap(initialCapacity);

 }

 

-PersistentHashMap(IMap impl){

+PersistentHybridMap(IPersistentMap impl){

     this.impl = impl;

 }

 

@@ -46,21 +46,21 @@ public IMapEntry find(Object key) {
     return impl.find(key);

 }

 

-public IMap add(Object key) {

+public IPersistentMap add(Object key) {

     return put(key, null);

 }

 

-public IMap put(Object key, Object val) {

-    IMap newImpl = impl.put(key,val);

+public IPersistentMap put(Object key, Object val) {

+    IPersistentMap newImpl = impl.put(key,val);

     if(newImpl.capacity() == CAPACITY_THRESHOLD)

         {

-        newImpl = createHashtableMap(((ArrayMap)newImpl).array);

+        newImpl = createHashtableMap(((PersistentArrayMap)newImpl).array);

         }

     return create(newImpl);

 }

 

-public IMap remove(Object key) {

-    IMap newImpl = impl.remove(key);

+public IPersistentMap remove(Object key) {

+    IPersistentMap newImpl = impl.remove(key);

     if(newImpl != impl)

         return create(newImpl);

     return this;

@@ -78,24 +78,24 @@ public Iterator iterator() {
     return ((Iterable)impl).iterator();

 }

 

-public IMap create(IMap impl) {

-    return new PersistentHashMap(impl);

+public IPersistentMap create(IPersistentMap impl) {

+    return new PersistentHybridMap(impl);

 }

 

-public ArrayMap createArrayMap(Object[] init) {

-    return new ArrayMap(init);

+public PersistentArrayMap createArrayMap(Object[] init) {

+    return new PersistentArrayMap(init);

 }

 

-private IMap createArrayMap() {

-    return new ArrayMap();

+private IPersistentMap createArrayMap() {

+    return new PersistentArrayMap();

 }

 

-private IMap createHashtableMap(Object[] init) {

-    return new HashtableMap(init);

+private IPersistentMap createHashtableMap(Object[] init) {

+    return new PersistentHashtableMap(init);

 }

 

-private IMap createHashtableMap(int initialCapacity) {

-    return new HashtableMap(initialCapacity);

+private IPersistentMap createHashtableMap(int initialCapacity) {

+    return new PersistentHashtableMap(initialCapacity);

 }

 

 }

diff --git a/src/org/clojure/runtime/IdentityArrayMap.java b/src/org/clojure/runtime/PersistentIdentityArrayMap.java
index ed0c7106..2e17cb4d 100644
--- a/src/org/clojure/runtime/IdentityArrayMap.java
+++ b/src/org/clojure/runtime/PersistentIdentityArrayMap.java
@@ -13,11 +13,11 @@ package org.clojure.runtime;
 /**

  * ArrayMap using identity (==) comparison instead of equals

  */

-public class IdentityArrayMap extends ArrayMap{

-public IdentityArrayMap() {

+public class PersistentIdentityArrayMap extends PersistentArrayMap {

+public PersistentIdentityArrayMap() {

 }

 

-public IdentityArrayMap(Object[] init) {

+public PersistentIdentityArrayMap(Object[] init) {

     super(init);

 }

 

diff --git a/src/org/clojure/runtime/PersistentIdentityHashtableMap.java b/src/org/clojure/runtime/PersistentIdentityHashtableMap.java
new file mode 100644
index 00000000..190fcb74
--- /dev/null
+++ b/src/org/clojure/runtime/PersistentIdentityHashtableMap.java
@@ -0,0 +1,38 @@
+/**

+ *   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.

+ **/

+

+package org.clojure.runtime;

+

+public class PersistentIdentityHashtableMap extends PersistentHashtableMap {

+

+public PersistentIdentityHashtableMap(int initialCapacity) {

+    super(initialCapacity);

+}

+

+public PersistentIdentityHashtableMap(Object[] init) {

+    super(init);

+}

+

+PersistentIdentityHashtableMap(int count, PersistentArray array) {

+    super(count, array);

+}

+

+IPersistentMap create(int capacity) {

+    return new PersistentIdentityHashtableMap(capacity);

+}

+

+IPersistentMap create(int count, PersistentArray array) {

+    return new PersistentIdentityHashtableMap(count, array);

+}

+

+IPersistentMap createArrayMap(Object[] init) {

+    return new PersistentIdentityArrayMap(init);

+}

+}

diff --git a/src/org/clojure/runtime/ListMap.java b/src/org/clojure/runtime/PersistentListMap.java
index 16c77e9c..cbe772d4 100644
--- a/src/org/clojure/runtime/ListMap.java
+++ b/src/org/clojure/runtime/PersistentListMap.java
@@ -26,12 +26,12 @@ import java.util.Iterator;
  *
  * null keys and values are ok, but you won't be able to distinguish a null value via get - use contains/find
  */
-public class ListMap implements IMap, IMapEntry
+public class PersistentListMap implements IPersistentMap, IMapEntry
 {
 
-static public ListMap EMPTY = new ListMap();
+static public PersistentListMap EMPTY = new PersistentListMap();
 
-static public ListMap create(Object key, Object val){
+static public PersistentListMap create(Object key, Object val){
 	return new Tail(key, val);
 }
 
@@ -43,7 +43,7 @@ public Object val(){
 	return null;
 }
 
-ListMap rest(){
+PersistentListMap rest(){
     return this;
     }
 
@@ -59,15 +59,15 @@ public IMapEntry find(Object key){
 	return null;
 }
 
-public IMap add(Object key){
+public IPersistentMap add(Object key){
 	return put(key, null);
 }
 
-public ListMap put(Object key, Object val){
+public PersistentListMap put(Object key, Object val){
 	return new Tail(key, val);
 }
 
-public ListMap remove(Object key){
+public PersistentListMap remove(Object key){
 	return this;
 }
 
@@ -80,9 +80,9 @@ public int capacity(){
 }
 
 static class Iter implements Iterator{
-	ListMap e;
+	PersistentListMap e;
 
-	Iter(ListMap e)
+	Iter(PersistentListMap e)
 	{
 	this.e = e;
 	}
@@ -92,7 +92,7 @@ static class Iter implements Iterator{
 	}
 
 	public Object next(){
-		ListMap ret = e;
+		PersistentListMap ret = e;
 		e = e.rest();
 		return ret;
 	}
@@ -106,7 +106,7 @@ public Iterator iterator(){
 	return new Iter(this);
 }
 
-static class Tail extends ListMap{
+static class Tail extends PersistentListMap {
 	final Object _key;
 	final Object _val;
 
@@ -115,7 +115,7 @@ static class Tail extends ListMap{
 		this._val = val;
 		}
 
-    ListMap rest(){
+    PersistentListMap rest(){
         return EMPTY;
     }
 
@@ -151,7 +151,7 @@ static class Tail extends ListMap{
 		return null;
 	}
 
-	public ListMap put(Object key, Object val){
+	public PersistentListMap put(Object key, Object val){
 		if(equalKey(key,_key))  //replace
 			{
 			if(val == _val)
@@ -161,19 +161,19 @@ static class Tail extends ListMap{
 		return new Link(key,val,this);
 	}
 
-	public ListMap remove(Object key){
+	public PersistentListMap remove(Object key){
 		if(equalKey(key,_key))
 			return EMPTY;
 		return this;
 	}
 }
 
-static class Link extends ListMap{
+static class Link extends PersistentListMap {
 	final Object _key;
 	final Object _val;
-	final ListMap _rest;
+	final PersistentListMap _rest;
 
-	Link(Object key,Object val,ListMap rest){
+	Link(Object key,Object val,PersistentListMap rest){
 		this._key = key;
 		this._val = val;
 		this._rest = rest;
@@ -187,7 +187,7 @@ static class Link extends ListMap{
 		return _val;
 	}
 
-	ListMap rest(){
+	PersistentListMap rest(){
         return _rest;
         }
 
@@ -205,7 +205,7 @@ static class Link extends ListMap{
 		return _rest.find(key);
 	}
 
-	public ListMap put(Object key, Object val){
+	public PersistentListMap put(Object key, Object val){
 		IMapEntry e = find(key);
 		if(e != null)
 			{
@@ -216,10 +216,10 @@ static class Link extends ListMap{
 		return new Link(key,val,this);
 	}
 
-	public ListMap remove(Object key){
+	public PersistentListMap remove(Object key){
 		if(equalKey(key,_key))
 			return _rest;
-		ListMap r = _rest.remove(key);
+		PersistentListMap r = _rest.remove(key);
 		if(r == _rest)  //not there
 			return this;
 		return create(_key,_val,r);
@@ -236,7 +236,7 @@ static class Link extends ListMap{
 		return count();
 	}
 
-	ListMap create(Object k,Object v,ListMap r){
+	PersistentListMap create(Object k,Object v,PersistentListMap r){
 		if(r == EMPTY)
 			return new Tail(k,v);
 		return new Link(k, v, r);
diff --git a/src/org/clojure/runtime/RBTree.java b/src/org/clojure/runtime/PersistentTree.java
index 6aec53e2..5c6a099f 100644
--- a/src/org/clojure/runtime/RBTree.java
+++ b/src/org/clojure/runtime/PersistentTree.java
@@ -22,17 +22,17 @@ import java.util.*;
  * See Okasaki, Kahrs, Larsen et al
  */
 
-public class RBTree implements Iterable, IMap {
+public class PersistentTree implements IPersistentMap {
 
 public final Comparator comp;
 public final Node tree;
 public final int _count;
 
-public RBTree(){
+public PersistentTree(){
 	this(null);
 }
 
-public RBTree(Comparator comp){
+public PersistentTree(Comparator comp){
 	this.comp = comp;
 	tree = null;
 	_count = 0;
@@ -42,11 +42,11 @@ public boolean contains(Object key){
 	return find(key) != null;
 }
 
-public RBTree add(Object key){
+public PersistentTree add(Object key){
 	return put(key, null);
 }
 
-public RBTree put(Object key, Object val){
+public PersistentTree put(Object key, Object val){
 	Box found = new Box(null);
 	Node t = add(tree, key, val, found);
 	if(t == null)   //null == already contains key
@@ -54,13 +54,13 @@ public RBTree put(Object key, Object val){
 		Node foundNode = (Node) found.val;
 		if(foundNode.val() == val)  //note only get same collection on identity of val, not equals()
 			return this;
-		return new RBTree(comp, replace(tree, key, val), _count);
+		return new PersistentTree(comp, replace(tree, key, val), _count);
 		}
-	return new RBTree(comp, t.blacken(), _count + 1);
+	return new PersistentTree(comp, t.blacken(), _count + 1);
 }
 
 
-public RBTree remove(Object key){
+public PersistentTree remove(Object key){
 	Box found = new Box(null);
 	Node t = remove(tree, key, found);
 	if(t == null)
@@ -68,9 +68,9 @@ public RBTree remove(Object key){
 		if(found.val == null)//null == doesn't contain key
 			return this;
 		//empty
-		return new RBTree(comp);
+		return new PersistentTree(comp);
 		}
-	return new RBTree(comp, t.blacken(), _count - 1);
+	return new PersistentTree(comp, t.blacken(), _count - 1);
 }
 
 
@@ -310,7 +310,7 @@ Node replace(Node t, Object key, Object val){
 	                 c > 0 ? replace(t.right(), key, val) : t.right());
 }
 
-RBTree(Comparator comp, Node tree, int count){
+PersistentTree(Comparator comp, Node tree, int count){
 	this.comp = comp;
 	this.tree = tree;
 	this._count = count;
@@ -676,9 +676,9 @@ static public void main(String args[]){
 		}
 	Collections.shuffle(Arrays.asList(ints));
 	//force the ListMap class loading now
-	ListMap.EMPTY.add(1).add(2).add(3);
+	PersistentListMap.EMPTY.add(1).add(2).add(3);
 	System.out.println("Building set");
-	IMap set = new PersistentHashMap(1001);
+	IPersistentMap set = new PersistentHybridMap(1001);
 	//IMap set = new HashtableMap(1001);
 	//IMap set = new ListMap();
 	//IMap set = new ArrayMap();
diff --git a/src/org/clojure/runtime/TObj.java b/src/org/clojure/runtime/TObj.java
index 8a0acb57..00d121fb 100644
--- a/src/org/clojure/runtime/TObj.java
+++ b/src/org/clojure/runtime/TObj.java
@@ -14,23 +14,23 @@ public class TObj implements IObj{
 TRef attrs;

 

 public TObj(ThreadLocalData tld) throws Exception{

-    this.attrs = Transaction.tref(tld,new RBTree());

+    this.attrs = Transaction.tref(tld,new PersistentTree());

 }

 

 public Object put(ThreadLocalData tld, Comparable key, Object val) throws Exception {

-    RBTree t = (RBTree) Transaction.get(tld, attrs);

+    PersistentTree t = (PersistentTree) Transaction.get(tld, attrs);

     t = t.put(key, val);

     Transaction.set(tld,attrs,t);

     return val;

 }

 

 public Object get(ThreadLocalData tld, Comparable key) throws Exception {

-    RBTree t = (RBTree) Transaction.get(tld, attrs);

+    PersistentTree t = (PersistentTree) Transaction.get(tld, attrs);

     return t.get(key);

 }

 

 public boolean has(ThreadLocalData tld, Comparable key) throws Exception {

-    RBTree t = (RBTree) Transaction.get(tld, attrs);

+    PersistentTree t = (PersistentTree) Transaction.get(tld, attrs);

     return t.contains(key);

 }

 }