src/Pure/PIDE/protocol.scala

     var touched = false
     var accepted = false
     var failed = false
     var forks = 0
     var runs = 0
-    for { markup <- markups; name = markup.name }
-      name match {
+    for (markup <- markups) {
+      markup.name match {
         case Markup.ACCEPTED => accepted = true
         case Markup.FORKED => touched = true; forks += 1
         case Markup.JOINED => forks -= 1
         case Markup.RUNNING => touched = true; runs += 1
         case Markup.FINISHED => runs -= 1
         case Markup.FAILED => failed = true
         case _ =>
       }
+    }
     Status(touched, accepted, failed, forks, runs)
   }
 
   val command_status_elements =
     Document.Elements(Markup.ACCEPTED, Markup.FORKED, Markup.JOINED, Markup.RUNNING,

     var unprocessed = 0
     var running = 0
     var finished = 0
     var warned = 0
     var failed = 0
-    for { command <- node.commands }
-    {
+    for (command <- node.commands.iterator) {
       val states = state.command_states(version, command)
       val status = command_status(states.iterator.flatMap(st => st.status.iterator))
 
       if (status.is_running) running += 1
       else if (status.is_finished) {

     var total = 0.0
     var commands = Map.empty[Command, Double]
     for {
       command <- node.commands.iterator
       st <- state.command_states(version, command)
-      command_timing =
+    } {
+      val command_timing =
         (0.0 /: st.status)({
           case (timing, Markup.Timing(t)) => timing + t.elapsed.seconds
           case (timing, _) => timing
         })
-    } {
       total += command_timing
       if (command_timing >= threshold) commands += (command -> command_timing)
     }
     Node_Timing(total, commands)
   }