src/Pure/Concurrent/consumer_thread.scala

       finish: () => Unit = () => ()
     ): Consumer_Thread[A] = {
     def consume_single(args: List[A]): (List[Exn.Result[Unit]], Boolean) = {
       assert(args.length == 1)
       Exn.capture { consume(args.head) } match {
-        case Exn.Res(continue) => (List(Exn.Res(())), continue)
+        case Exn.Res(cont) => (List(Exn.Res(())), cont)
         case Exn.Exn(exn) => (List(Exn.Exn(exn)), true)
       }
     }
 
     fork_bulk(name = name, daemon = daemon)(_ => false, consume_single, finish = finish)

         val reqs =
           proper_list(msgs.takeWhile(msg => msg.isDefined && bulk(msg.get.arg)))
             .getOrElse(msgs.take(1))
             .map(_.get)
 
-        val (results, continue) = consume(reqs.map(_.arg))
+        val (results, cont) = consume(reqs.map(_.arg))
 
         for {
           (Some(req), Some(res)) <- reqs.map(Some(_)).zipAll(results.map(Some(_)), None, None)
         } {
           (req.ack, res) match {

             case (None, Exn.Res(_)) =>
             case (None, Exn.Exn(exn)) => failure(exn)
           }
         }
 
-        if (continue) main_loop(msgs.drop(reqs.length))
+        if (cont) main_loop(msgs.drop(reqs.length))
         else robust_finish()
     }
 
 
   /* main methods */