Create Future without starting it

You can do something like this

val p = Promise[Unit]()
val f = p.future

//... some code run at a later time
p.success {
// your function
}

LATER EDIT:

I think the pattern you're looking for can be encapsulated like this:

class LatentComputation[T](f: => T) {
  private val p = Promise[T]()

  def trigger() { p.success(f) }

  def future: Future[T] = p.future
}

object LatentComputation {
  def apply[T](f: => T) = new LatentComputation(f)
}

You would use it like this:

val comp = LatentComputation {
// your code to be executed later
}

val f = comp.future

// somewhere else in the code
comp.trigger()

You could always defer creation with a closure, you'll not get the future object right ahead, but you get a handle to call later.

type DeferredComputation[T,R] = T => Future[R]

def deferredCall[T,R](futureBody: T => R): DeferredComputation[T,R] =
  t => future {futureBody(t)}

def deferredResult[R](futureBody: => R): DeferredComputation[Unit,R] =
  _ => future {futureBody}

If you are getting too fancy with execution control, maybe you should be using actors instead?

Or, perhaps, you should be using a Promise instead of a Future: a Promise can be passed on to others, while you keep it to "fulfill" it at a later time.