Did some refactoring.

10 files changed, 36 insertions, 28 deletions

diff --git a/sources/scala/DefaultMapModel.scala b/sources/scala/DefaultMapModel.scala
index 36224bcaa3..2e272dc59b 100644
--- a/sources/scala/DefaultMapModel.scala
+++ b/sources/scala/DefaultMapModel.scala
@@ -14,11 +14,9 @@ package scala;
 
 trait DefaultMapModel[A, B] extends MutableMap[A, B] {
 
-    protected def findEntry(key: A): Option[Entry];
+	protected def findEntry(key: A): Option[Entry];
 
-    protected def addEntry(e: Entry): Unit;
-
-    protected def removeEntry(key: A): Unit;
+	protected def addEntry(e: Entry): Unit;
 
     protected def entries: Iterator[Entry];
 
@@ -32,11 +30,6 @@ trait DefaultMapModel[A, B] extends MutableMap[A, B] {
         case Some(e) => e.value = value;
     }
 
-    def remove(key: A) = findEntry(key) match {
-    	case None => null;
-    	case Some(e) => removeEntry(key); e.value;
-    }
-
     def elements = new Iterator[Pair[A, B]] {
         val iter = entries;
         def hasNext = iter.hasNext;
diff --git a/sources/scala/HashSet.scala b/sources/scala/HashSet.scala
index 763222b526..7674a4f5a8 100644
--- a/sources/scala/HashSet.scala
+++ b/sources/scala/HashSet.scala
@@ -23,8 +23,6 @@ class HashSet[A] extends Set[A] with HashTable[A] {
         case Some(_) =>
     }
 
-    def remove(elem: A): Unit = removeEntry(elem);
-
     def elements = entries;
 
     protected type Entry = A;
diff --git a/sources/scala/HashTable.scala b/sources/scala/HashTable.scala
index c1d3042be4..2e0171f8b2 100644
--- a/sources/scala/HashTable.scala
+++ b/sources/scala/HashTable.scala
@@ -53,7 +53,7 @@ abstract class HashTable[A] {
             resize(2 * table.length);
     }
 
-    protected def removeEntry(key: A): Unit = {
+    def remove(key: A): Unit = {
         val old = findEntry(key);
         old match {
             case None =>
diff --git a/sources/scala/Iterator.scala b/sources/scala/Iterator.scala
index 8325f0e5a6..3b7a6a9f43 100644
--- a/sources/scala/Iterator.scala
+++ b/sources/scala/Iterator.scala
@@ -1,3 +1,12 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
 package scala;
 
 trait Iterator[+a] {
diff --git a/sources/scala/ListMap.scala b/sources/scala/ListMap.scala
index bdf316b22d..5c6b5ed5bc 100644
--- a/sources/scala/ListMap.scala
+++ b/sources/scala/ListMap.scala
@@ -10,8 +10,7 @@
 package scala;
 
 
-class ListMap[A, B] extends MutableMap[A, B]
-                    with DefaultMapModel[A, B] {
+class ListMap[A, B] extends MutableMap[A, B] with DefaultMapModel[A, B] {
 
 	var xs: List[Entry] = Nil;
 
@@ -23,7 +22,7 @@ class ListMap[A, B] extends MutableMap[A, B]
 
 	protected def addEntry(e: Entry) = { xs = e :: xs; }
 
-    protected def removeEntry(key: A) = { xs = xs filter {e => e.key != key}; }
+    def remove(key: A) = { xs = xs filter {e => e.key != key}; }
 
 	protected def entries = xs.elements;
 }
diff --git a/sources/scala/Map.scala b/sources/scala/Map.scala
index 0a42a7fccd..3441d6e99e 100644
--- a/sources/scala/Map.scala
+++ b/sources/scala/Map.scala
@@ -20,13 +20,13 @@ trait Map[A, +B] with Function1[A, B]
     def isEmpty: Boolean = (size == 0);
 
     def apply(key: A): B = get(key) match {
-        case None => null
+        case None => error("key not found")
         case Some(value) => value
     }
 
     def get(key: A): Option[B];
 
-    def remove(key: A): B;
+    def remove(key: A): Unit;
 
     def contains(key: A): Boolean = get(key) match {
         case None => false
diff --git a/sources/scala/MutableList.scala b/sources/scala/MutableList.scala
index d540221284..d30a388634 100644
--- a/sources/scala/MutableList.scala
+++ b/sources/scala/MutableList.scala
@@ -29,14 +29,14 @@ class MutableList[A] with Seq[A] with PartialFunction[Int, A] {
 
     def at(n: Int): A = apply(n);
 
-    protected def prependElem(elem: A) = {
+    protected def prependElem(elem: A): Unit = {
     	first = new LinkedList[A](elem, first);
         if (len == 0)
             last = first;
         len = len + 1;
     }
 
-    protected def appendElem(elem: A) = {
+    protected def appendElem(elem: A): Unit = {
         if (len == 0)
             prependElem(elem);
         else {
diff --git a/sources/scala/Predef.scala b/sources/scala/Predef.scala
index 33a5cb7987..895b3087cc 100644
--- a/sources/scala/Predef.scala
+++ b/sources/scala/Predef.scala
@@ -33,7 +33,7 @@ object Predef {
         set;
     }
 
-    def Map[A, B](mappings: Pair[A, B]*): Map[A, B] = {
+    def Map[A, B](mappings: Pair[A, B]*): MutableMap[A, B] = {
         val map = new HashMap[A, B];
         map.putMap(mappings);
         map;
diff --git a/sources/scala/Queue.scala b/sources/scala/Queue.scala
index 2d885c2856..7ab2011bea 100644
--- a/sources/scala/Queue.scala
+++ b/sources/scala/Queue.scala
@@ -18,14 +18,14 @@ class Queue[A] with MutableList[A] {
 
     def enqueue(elems: A*): Unit = (this += elems);
 
-    def dequeue(): A = {
-    	if (first == null)
-    		error("queue empty");
-    	else {
-    		val res = first.elem;
-    		first = first.next;
-    		res;
-    	}
+    def dequeue: A = {
+        if (first == null)
+            error("queue empty");
+        else {
+            val res = first.elem;
+            first = first.next;
+            res;
+        }
     }
 
     def clear: Unit = reset;
diff --git a/sources/scala/Set.scala b/sources/scala/Set.scala
index 6f6074247e..5da0dddd08 100644
--- a/sources/scala/Set.scala
+++ b/sources/scala/Set.scala
@@ -63,6 +63,15 @@ trait Set[A] with Iterable[A] {
         elem => if (p(elem)) remove(elem);
     }
 
+    def exists(p: A => Boolean): Boolean = {
+    	val iter = elements;
+    	var res = false;
+        while (!res && iter.hasNext) {
+            if (p(iter.next)) { res = true; }
+        }
+        res;
+    }
+
     def toList: List[A] = {
         var res: List[A] = Nil;
         val iter = elements;