       rescue
         ArgumentError -> :ok
       end
+      #=> :ok
 
   The most common Erlang errors will be transformed into their
-  Elixir counter-part. Those which are not will be transformed
-  into `ErlangError`:
+  Elixir counterpart. Those which are not will be transformed
+  into the more generic `ErlangError`:
 
       try do
         :erlang.error(:unknown)
       rescue
         ErlangError -> :ok
       end
+      #=> :ok
 
   In fact, `ErlangError` can be used to rescue any error that is
   not a proper Elixir error. For example, it can be used to rescue

        IO.puts "This is printed regardless if it failed or succeed"
      end

  The `rescue` clause is used to handle exceptions, while the `catch`
  clause can be used to catch thrown values and exits.
  The `else` clause can be used to control flow based on the result of
  the expression. `catch`, `rescue`, and `else` clauses work based on

  exception by its name. All the following formats are valid patterns
  in `rescue` clauses:

      # Rescue a single exception without binding the exception
      # to a variable
      try do
        UndefinedModule.undefined_function
      rescue
        UndefinedFunctionError -> nil
      end

      # Rescue any of the given exception without binding
      try do
        UndefinedModule.undefined_function
      rescue
        [UndefinedFunctionError, ArgumentError] -> nil
      end

      # Rescue and bind the exception to the variable "x"
      try do
        UndefinedModule.undefined_function
      rescue
        x in [UndefinedFunctionError] -> nil
      end

      # Rescue all kinds of exceptions and bind the rescued exception
      # to the variable "x"
      try do
        UndefinedModule.undefined_function
      rescue
        x -> nil
      end

  ### Erlang errors

  Erlang errors are transformed into Elixir ones when rescuing:

