canonical list operations, as in ML;
avoid odd mutable data structures;

--- a/src/Pure/System/event_bus.scala	Thu Apr 24 00:27:06 2014 +0200
+++ b/src/Pure/System/event_bus.scala	Thu Apr 24 00:29:55 2014 +0200
@@ -9,29 +9,24 @@
 
 
 import scala.actors.Actor, Actor._
-import scala.collection.mutable.ListBuffer
 
 
 class Event_Bus[Event]
 {
   /* receivers */
 
-  private val receivers = new ListBuffer[Actor]
+  private val receivers = Synchronized(List.empty[Actor])
 
-  def += (r: Actor) { synchronized { receivers += r } }
-  def + (r: Actor): Event_Bus[Event] = { this += r; this }
+  def += (r: Actor) { receivers >> (rs => Library.insert(r, rs)) }
 
   def += (f: Event => Unit) {
     this += actor { loop { react { case x => f(x.asInstanceOf[Event]) } } }
   }
 
-  def + (f: Event => Unit): Event_Bus[Event] = { this += f; this }
-
-  def -= (r: Actor) { synchronized { receivers -= r } }
-  def - (r: Actor) = { this -= r; this }
+  def -= (r: Actor) { receivers >> (rs => Library.remove(r, rs)) }
 
 
   /* event invocation */
 
-  def event(x: Event) { synchronized { receivers.foreach(_ ! x) } }
+  def event(x: Event) { receivers().reverseIterator.foreach(_ ! x) }
 }

--- a/src/Pure/library.scala	Thu Apr 24 00:27:06 2014 +0200
+++ b/src/Pure/library.scala	Thu Apr 24 00:29:55 2014 +0200
@@ -153,6 +153,14 @@
   }
 
 
+  /* canonical list operations */
+
+  def member[A, B](x: B, xs: List[A]): Boolean = xs.exists(_ == x)
+  def insert[A](x: A, xs: List[A]): List[A] = if (member(x, xs)) xs else x :: xs
+  def remove[A, B](x: B, xs: List[A]): List[A] = if (member(x, xs)) xs.filterNot(_ == x) else xs
+  def update[A](x: A, xs: List[A]): List[A] = x :: remove(x, xs)
+
+
   /* Java futures */
 
   def future_value[A](x: A) = new JFuture[A]