further tweak Future doc

SethTisue · SethTisue · commit 408561130340 · 2016-08-26T11:40:34.000-07:00
followup to 5bbe5bb
diff --git a/overviews/core/_posts/2012-09-20-futures.md b/overviews/core/_posts/2012-09-20-futures.md
@@ -200,13 +200,13 @@ once.
 Once a `Future` object is given a value or an exception, it becomes
 in effect immutable-- it can never be overwritten.
 
-The simplest way to create a future object is to invoke the `Future`
+The simplest way to create a future object is to invoke the `Future.apply`
 method which starts an asynchronous computation and returns a
 future holding the result of that computation.
 The result becomes available once the future completes.
 
 Note that `Future[T]` is a type which denotes future objects, whereas
-`Future` is a method which creates and schedules an asynchronous
+`Future.apply` is a method which creates and schedules an asynchronous
 computation, and then returns a future object which will be completed
 with the result of that computation.
 
@@ -226,7 +226,7 @@ a request to obtain a list of friends of a particular user:
     }
 
 Above, we first import the contents of the `scala.concurrent` package
-to make the type `Future` and the construct `Future` visible.
+to make the type `Future` visible.
 We will explain the second import shortly.
 
 We then initialize a session variable which we will use to send
@@ -237,7 +237,7 @@ has to be sent over a network, which can take a long time.
 This is illustrated with the call to the method `getFriends` that returns `List[Friend]`.
 To better utilize the CPU until the response arrives, we should not
 block the rest of the program-- this computation should be scheduled
-asynchronously. The `Future` method does exactly that-- it performs
+asynchronously. The `Future.apply` method does exactly that-- it performs
 the specified computation block concurrently, in this case sending
 a request to the server and waiting for a response.
 
@@ -258,7 +258,7 @@ The line `import ExecutionContext.Implicits.global` above imports
 the default global execution context.
 Execution contexts execute tasks submitted to them, and
 you can think of execution contexts as thread pools.
-They are essential for the `Future` method because
+They are essential for the `Future.apply` method because
 they handle how and when the asynchronous computation is executed.
 You can define your own execution contexts and use them with `Future`,
 but for now it is sufficient to know that
@@ -749,7 +749,7 @@ the throwable types it matches.
 -->
 
 <!--
-Invoking the `Future` construct uses a global execution context to start an asynchronous computation. In the case the client desires to use a custom execution context to start an asynchronous computation:
+Invoking the `Future.apply` construct uses a global execution context to start an asynchronous computation. In the case the client desires to use a custom execution context to start an asynchronous computation:
 
     val f = customExecutionContext Future {
       4 / 2
