   Multiple uses of `@compile` will accumulate instead of overriding
   previous ones. See the "Compile options" section below.
 
-  ### @doc
+  ### `@doc`
 
   Provides documentation for the function or macro that follows the
   attribute.
 
   Accepts a string (often a heredoc) or `false` where `@doc false` will
-  make the function/macro invisible to the documentation extraction tools
+  make the function/macro invisible to documentation extraction tools
   like ExDoc. For example:
 
-      defmodule M do
+      defmodule MyModule do
         @doc "Hello world"
         def hello do
           "world"

  def __info__(kind)

  @doc """
  Checks if a module is open, i.e. it is currently being defined
  and its attributes and functions can be modified.
  """
  @spec open?(module) :: boolean
  def open?(module) when is_atom(module) do

        end
      end

  ### `@moduledoc`

  Provides documentation for the current module.

      defmodule MyModule do
        @moduledoc """
        A very useful module.
        """
      end

  Accepts a string (often a heredoc) or `false` where
  `@moduledoc false` will make the module invisible to
  documentation extraction tools like ExDoc.

  ### `@on_definition`

  A hook that will be invoked when each function or macro in the current
  module is defined. Useful when annotating functions.

  Accepts a module or a `{module, function_name}` tuple. See the
  "Compile callbacks" section below.

  ### `@on_load`

  A hook that will be invoked whenever the module is loaded.

  Accepts the function name (as an atom) of a function in the current module.
  The function must have arity 0 (no arguments) and has to return `:ok`, otherwise
  the loading of the module will be aborted. For example:

      defmodule MyModule do
        @on_load :load_check

        def load_check do
