       rescue
         ErlangError -> :ok
       end
-
-  ## Catching throws and exits
-
-  The `catch` clause can be used to catch thrown values and exits.
+      #=> :ok
+
+  ## `catch` clauses
+
+  The `catch` clause can be used to catch thrown values, exits, and errors.
+
+  ### Catching thrown values
+
+  `catch` can be used to catch values thrown by `Kernel.throw/1`:
 
       try do
-        exit(:shutdown)
+        throw(:some_value)
       catch
-        :exit, :shutdown ->
-          IO.puts "Exited with shutdown reason"
-      end
-
-      try do
-        throw(:sample)
-      catch
-        :throw, :sample ->
-          IO.puts ":sample was thrown"
-      end
-
-  The `catch` clause also supports `:error` alongside `:exit` and `:throw`, as
-  in Erlang, although it is commonly avoided in favor of `raise`/`rescue` control
+        thrown_value ->
+          IO.puts "A value was thrown: #{inspect(thrown_value)}"
+      end
+
+  ### Catching values of any kind
+
+  The `catch` clause also supports catching exits and errors. To do that, it
+  allows matching on both the *kind* of the caught value as well as the value
+  itself:
+
+    try do
+      exit(:shutdown)
+    catch
+      :exit, value
+        IO.puts "Exited with value #{inspect(value)}"
+    end
+
+    try do
+      exit(:shutdown)
+    catch
+      kind, value when kind in [:exit, :throw] ->
+        IO.puts "Caught exit or throw with value #{inspect(value)}"
+    end
+
+  The `catch` clause also supports `:error` alongside `:exit` and `:throw` as
+  in Erlang, although this is commonly avoided in favor of `raise`/`rescue` control
   mechanisms. One reason for this is that when catching `:error`, the error is
   not automatically transformed into an Elixir error:
 
       try do
         :erlang.error(:badarg)
       catch
-        :error, :badarg ->
-          :ok
-      end
-
-  Note that it is possible to match both on the caught value as well as the *kind*
-  of such value:
-
-      try do
-        exit(:shutdown)
-      catch
-        kind, value when kind in [:exit, :throw] ->
-          IO.puts "Exited with or thrown value #{inspect(value)}"
-      end
+        :error, :badarg -> :ok
+      end
+      #=> :ok
 
   ## `after` clauses
 
   An `after` clause allows you to define cleanup logic that will be invoked both
-  when the tried block of code succeeds and also when an error is raised. Note
-  that the process will exit as usually when receiving an exit signal that causes
+  when the block of code passed to `try/1` succeeds and also when an error is raised. Note
+  that the process will exit as usual when receiving an exit signal that causes
   it to exit abruptly and so the `after` clause is not guaranteed to be executed.
   Luckily, most resources in Elixir (such as open files, ETS tables, ports, sockets,
-  etc.) are linked to or monitor the owning process and will automatically clean
+  and so on) are linked to or monitor the owning process and will automatically clean
   themselves up if that process exits.
 
       File.write!("tmp/story.txt", "Hello, World")


  ## `else` clauses

  `else` clauses allow the result of the tried expression to be pattern
  matched on:

      x = 2

        try do
          1 / x
        rescue
          # The TryClauseError cannot be rescued here:
          TryClauseError ->
            :error_a
        else
