I am trying to build a new control structure which create a thread for each of its argument, and run them in parallel. The code seems to be fine when I built two future manually for each input, because I see the fast thread finishes before the slow thread. 

Here is output:

```
fast
slow

```

However, if I use `List(a, b).map(f => Future {f})` then I always see fast thread is executed after slow is done. Here is the output:

```
slow
fast

```

Can someone explain this?

code pasted here:

```
import java.util.concurrent.Executors

import scala.concurrent.{ExecutionContext, Future}

object ExecInParallel extends App {

  def run(a: => Unit, b: => Unit): Unit = {

    val executorService = Executors.newFixedThreadPool(2)
    implicit val executionContext = 
    ExecutionContext.fromExecutorService(executorService)

    // af and bf are executed in parallel
    val af = Future(a)
    val bf = Future(b)

    // however, the following code is not parallel
    List(a, b).map(f => Future(f))

    Thread.sleep(3000)
    executorService.shutdown
  }

  run(
    {
      Thread.sleep(2000)
      println("slow")
    }, 
    {
      Thread.sleep(1000)
      println("fast")
    }
  )
}

```