Got framework and tests to compile with new exception refactoring.

Author: axel22

src/main/scala/scala/reactive/Channel.scala

@@ -64,21 +64,25 @@ trait Channel[@spec(Int, Long, Double) T] {
 
   /** Checks if this channel was terminated.
    *
-   *  A channel is terminated if it is sealed and all its reactives are unreacted.
+   *  A channel is terminated if it is sealed and all its reactives are
+   *  unreacted.
    *
    *  @return        `true` if the channel is terminated, `false` otherwise
    */
   def isTerminated: Boolean
 
   /** Composes this channel with a custom mapping function for the input events.
    *  
-   *  Events from reactives passed to this channel are mapped inside their isolates.
+   *  Events from reactives passed to this channel are mapped inside their
+   *  isolates.
    *
    *  @tparam S      type of the events the new channel will accept
-   *  @param f       maps events in the resulting channel to events of the original channel
+   *  @param f       maps events in the resulting channel to events of the
+   *                 original channel
    *  @return        the new channel accepting events of type `S`
    */
-  def compose[@spec(Int, Long, Double) S](f: S => T) = new Channel.Composed(this, f)
+  def compose[@spec(Int, Long, Double) S](f: S => T) =
+    new Channel.Composed(this, f)
 
   /** Creates and attaches a reactive emitter to the channel.
    *
@@ -141,7 +145,8 @@ trait Channel[@spec(Int, Long, Double) T] {
  */
 object Channel {
 
-  private[reactive] class Composed[@spec(Int, Long, Double) T, @spec(Int, Long, Double) S]
+  private[reactive] class Composed
+    [@spec(Int, Long, Double) T, @spec(Int, Long, Double) S]
     (val self: Channel[T], val f: S => T)
   extends Channel[S] {
     def attach(r: Reactive[S]): Channel[S] = {
@@ -164,14 +169,16 @@ object Channel {
    *  @param reactor   the reactor notified of this channel's events
    *  @param monitor   private monitor object used for synchronization
    */
-  class Synced[@spec(Int, Long, Double) T](val reactor: Reactor[T], val monitor: util.Monitor)
+  class Synced[@spec(Int, Long, Double) T]
+    (val reactor: Reactor[T], val monitor: util.Monitor)
   extends Channel[T] {
     private var sealedChannel = false
     private val reactives = mutable.Map[Reactive[T], Reactive.Subscription]()
     def attach(r: Reactive[T]) = monitor.synchronized {
       if (!sealedChannel) {
         if (!reactives.contains(r)) reactives(r) = r.observe(new Reactor[T] {
           def react(event: T) = reactor.react(event)
+          def except(t: Throwable) = reactor.except(t)
           def unreact() {
             monitor.synchronized { reactives.remove(r) }
             checkTerminated()

src/main/scala/scala/reactive/RPair.scala

@@ -177,9 +177,9 @@ trait RPair[@spec(Int, Long, Double) P, Q <: AnyRef] {
       try mutation(asSignal)
       catch {
         case t if isNonLethal(t) =>
-          mutable.except(t)
+          mutable.exception(t)
       }
-      mutable.react()
+      mutable.mutation()
     }
   }
 

src/main/scala/scala/reactive/RValPair.scala

@@ -133,9 +133,9 @@ trait RValPair[@spec(Int, Long, Double) P, @spec(Int, Long, Double) Q] {
       try mutation(asSignal)
       catch {
         case t if isNonLethal(t) =>
-          mutable.except(t)
+          mutable.exception(t)
       }
-      mutable.react()
+      mutable.mutation()
     }
   }
 

src/main/scala/scala/reactive/ReactMutable.scala

@@ -18,9 +18,12 @@ trait ReactMutable {
   /** Called internally - when the mutable reactive or its internal value has
    *  been mutated.
    */
-  def react(): Unit
+  def mutation(): Unit
 
-  def except(t: Throwable): Unit
+  /** Called when an exception occurs during mutation.
+   *  Some reactive mutables may propagate the exception further.
+   */
+  def exception(t: Throwable): Unit
 
 }
 

src/main/scala/scala/reactive/Reactive.scala

@@ -427,8 +427,8 @@ trait Reactive[@spec(Int, Long, Double) +T] {
     rm
   }
 
-  private def mutablesCompositeSubscription[M <: ReactMutable](
-    mutables: Seq[M], selfsub: Reactive.Subscription) = {
+  private def mutablesCompositeSubscription[M <: ReactMutable]
+    (mutables: Seq[M], selfsub: Reactive.Subscription) = {
     for (m <- mutables) yield m.bindSubscription(selfsub)
   }
 
@@ -1248,10 +1248,10 @@ object Reactive {
           except(t)
           // note: still need to mutate, just in case
       }
-      mutable.react()
+      mutable.mutation()
     }
     def except(t: Throwable) {
-      mutable.except(t)
+      mutable.exception(t)
     }
     def unreact() {}
     var subscription = Subscription.empty
@@ -1266,13 +1266,13 @@ object Reactive {
         mutation(value)
       } catch {
         case t if isNonLethal(t) =>
-          except(t)
+          exception(t)
           // note: still need to mutate, just in case
       }
-      for (m <- mutables) m.react()
+      for (m <- mutables) m.mutation()
     }
     def except(t: Throwable) {
-      for (m <- mutables) m.except(t)
+      for (m <- mutables) m.exception(t)
     }
     def unreact() {}
     var subscription = Subscription.empty