       to any supervisor, you may leave dangling tasks in case
       the parent dies.
 
-  ## Message format
-
-  The reply sent by the task will be in the format `{ref, result}`,
-  where `ref` is the monitor reference held by the task struct
-  and `result` is the return value of the task function.
+  """
+  @spec async((() -> any)) :: t
+  def async(fun) when is_function(fun, 0) do
+    async(:erlang, :apply, [fun, []])
+  end
+
+  @doc """
+  Starts a task that must be awaited on.
+
+  Similar to `async/1` except the function to be started is
+  specified by the given `module`, `function_name`, and `args`.
   """
   @spec async(module, atom, [term]) :: t
   def async(module, function_name, args)

  to be able to check multiple times if a long-running task has finished
  its computation, use `yield/2` instead.

  ## Compatibility with OTP behaviours

  It is not recommended to `await` a long-running task inside an OTP
  behaviour such as `GenServer`. Instead, you should match on the message
  coming from a task inside your `c:GenServer.handle_info/2` callback. For
  more information on the format of the message, see the documentation for
  `async/1`.

  ## Examples

      iex> task = Task.async(fn -> 1 + 1 end)
      iex> Task.await(task)
      2

  """
  @spec await(t, timeout) :: term

    end
  end

  @doc ~S"""
  Awaits a task reply and returns it.

  In case the task process dies, the current process will exit with the same
