       end)
       |> Enum.take(10)
 
-  In cases like the above, it is important to keep in mind that you will
-  likely end-up processing more items than required. For instance, in a
-  machine with 8 cores, the above will process 16 items, even though you
-  want only 10 elements, since `async_stream/3` process items concurrently.
-  So it will process 8 elements at once. Then all 8 elements complete at
-  roughly the same time, causing 8 elements to be kicked off for processing.
-  Out of these extra 8, only 2 will be used, and the rest will be terminated.
+  Running the example above in a machine with 8 cores will process 16 items,
+  even though you want only 10 elements, since `async_stream/3` process items
+  concurrently. That's because it will process 8 elements at once. Then all 8
+  elements complete at roughly the same time, causing 8 elements to be kicked
+  off for processing. Out of these extra 8, only 2 will be used, and the rest
+  will be terminated.
 
   Depending on the problem, you can filter or limit the number of elements
   upfront:


    * `:on_timeout` - what to do when a task times out. The possible
      values are:
      * `:exit` (default) - the process that spawned the tasks exits.
      * `:kill_task` - the task that timed out is killed. The value
        emitted for that task is `{:exit, :timeout}`.


  be controlled via options (see the "Options" section below).

  Consider using `Task.Supervisor.async_stream/6` to start tasks
  under a supervisor. If you find yourself trapping exits to ensure
  errors in the tasks do not terminate the caller process, consider
  using `Task.Supervisor.async_stream_nolink/6` to start tasks that
  are not linked to the caller process.

  ## Options

