src/Pure/Concurrent/future.scala

   def is_finished: Boolean = peek.isDefined
   def get_finished: A = { require(is_finished, "future not finished"); Exn.release(peek.get) }
   def join_result: Exn.Result[A]
   def join: A = Exn.release(join_result)
   def map[B](f: A => B): Future[B] = Future.fork { f(join) }
-  def cancel: Unit
+  def cancel(): Unit
 
   override def toString: String =
     peek match {
       case None => "<future>"
       case Some(Exn.Exn(_)) => "<failed>"

 
 private class Value_Future[A](x: A) extends Future[A]
 {
   val peek: Option[Exn.Result[A]] = Some(Exn.Res(x))
   def join_result: Exn.Result[A] = peek.get
-  def cancel: Unit = {}
+  def cancel(): Unit = {}
 }
 
 
 /* task future via thread pool */
 

         case st => (false, st)
       }
     if (do_run) {
       val result = Exn.capture(body)
       status.change(_ => Terminated)
-      status.change(_ => Finished(if (Thread.interrupted) Exn.Exn(Exn.Interrupt()) else result))
+      status.change(_ => Finished(if (Thread.interrupted()) Exn.Exn(Exn.Interrupt()) else result))
     }
   }
   private val task = Isabelle_Thread.pool.submit(new Callable[Unit] { def call = try_run() })
 
   def join_result: Exn.Result[A] =

       case st @ Finished(result) => Some((result, st))
       case _ => None
     }
   }
 
-  def cancel =
+  def cancel(): Unit =
   {
     status.change {
       case Ready => task.cancel(false); Finished(Exn.Exn(Exn.Interrupt()))
-      case st @ Running(thread) => thread.interrupt; st
+      case st @ Running(thread) => thread.interrupt(); st
       case st => st
     }
   }
 }
 

   def fulfill_result(result: Exn.Result[A]): Unit =
     state.change(st => if (st.isEmpty) Some(result) else throw new IllegalStateException)
 
   def fulfill(x: A): Unit = fulfill_result(Exn.Res(x))
 
-  def cancel: Unit =
+  def cancel(): Unit =
     state.change(st => if (st.isEmpty) Some(Exn.Exn(Exn.Interrupt())) else st)
 }
 
 
 /* thread future */

       inherit_locals = inherit_locals, uninterruptible = uninterruptible)
     { result.fulfill_result(Exn.capture(body)) }
 
   def peek: Option[Exn.Result[A]] = result.peek
   def join_result: Exn.Result[A] = result.join_result
-  def cancel: Unit = thread.interrupt
+  def cancel(): Unit = thread.interrupt()
 }