 
       tasks_with_results = Task.yield_many(tasks, 5000)
 
-      results = Enum.map(tasks_with_results, fn {task, res} ->
-        # Shutdown the tasks that did not reply nor exit
-        res || Task.shutdown(task, :brutal_kill)
-      end)
+      results =
+        Enum.map(tasks_with_results, fn {task, res} ->
+          # Shutdown the tasks that did not reply nor exit
+          res || Task.shutdown(task, :brutal_kill)
+        end)
 
       # Here we are matching only on {:ok, value} and
       # ignoring {:exit, _} (crashed tasks) and `nil` (no replies)
       for {:ok, value} <- results do
-        IO.inspect value
+        IO.inspect(value)
       end
 
   In the example above, we create tasks that sleep from 1

  The concurrency can be increased or decreased using the `:max_concurrency`
  option. For example, if the tasks are IO heavy, the value can be increased:

      max_concurrency = System.schedulers_online * 2
      stream = Task.async_stream(collection, Mod, :expensive_fun, [], max_concurrency: max_concurrency)
      Enum.to_list(stream)


  by computing a value asynchronously:

      task = Task.async(fn -> do_some_work() end)
      res = do_some_other_work()
      res + Task.await(task)

  Tasks spawned with `async` can be awaited on by their caller
