 
   The `@doc` annotation immediately preceding `use Supervisor` will be
   attached to the generated `child_spec/1` function.
-
-  ## `start_link/2`, `init/2`, and strategies
-
-  So far we have started the supervisor passing a single child as a tuple
-  as well as a strategy called `:one_for_one`:
-
-      children = [
-        {Stack, [:hello]}
-      ]
-
-      Supervisor.start_link(children, strategy: :one_for_one)
-
-  or from inside the `c:init/1` callback:
-
-      children = [
-        {Stack, [:hello]}
-      ]
-
-      Supervisor.init(children, strategy: :one_for_one)
-
-  The first argument given to `start_link/2` and `init/2` is a list of child
-  specifications as defined in the "child_spec/1" section above.
-
-  The second argument is a keyword list of options:
-
-    * `:strategy` - the supervision strategy option. It can be either
-      `:one_for_one`, `:rest_for_one` or `:one_for_all`. Required.
-      See the "Strategies" section.
-
-    * `:max_restarts` - the maximum number of restarts allowed in
-      a time frame. Defaults to `3`.
-
-    * `:max_seconds` - the time frame in which `:max_restarts` applies.
-      Defaults to `5`.
-
-    * `:name` - a name to register the supervisor process. Supported values are
-      explained in the "Name registration" section in the documentation for
-      `GenServer`. Optional.
-
-  ### Strategies
-
-  Supervisors support different supervision strategies (through the
-  `:strategy` option, as seen above):
-
-    * `:one_for_one` - if a child process terminates, only that
-      process is restarted.
-
-    * `:one_for_all` - if a child process terminates, all other child
-      processes are terminated and then all child processes (including
-      the terminated one) are restarted.
-
-    * `:rest_for_one` - if a child process terminates, the terminated child
-      process and the rest of the children started after it, are terminated and
-      restarted.
-
-  In the above, process termination refers to unsuccessful termination, which
-  is determined by the `:restart` option.
-
-  To dynamically supervise children, see `DynamicSupervisor`.
-
-  ### Name registration
-
-  A supervisor is bound to the same name registration rules as a `GenServer`.
-  Read more about these rules in the documentation for `GenServer`.
 
   ## Start and shutdown
 

  ## Examples

  In order to start a supervisor, we need to first define a child process
  that will be supervised. As an example, we will define a GenServer that
  represents a stack:

      defmodule Stack do
        use GenServer

        def start_link(state) do
          GenServer.start_link(__MODULE__, state, name: __MODULE__)
        end

        ## Callbacks

        @impl true
        def init(stack) do
          {:ok, stack}
        end

        @impl true
        def handle_call(:pop, _from, [head | tail]) do
          {:reply, head, tail}
        end

        @impl true
        def handle_cast({:push, head}, tail) do
          {:noreply, [head | tail]}
        end
      end

  The stack is a small wrapper around lists. It allows us to put
  an element on the top of the stack, by prepending to the list,
  and to get the top of the stack by pattern matching.

  We can now start a supervisor that will start and supervise our
  stack process. The first step is to define a list of **child
  specifications** that control how each child behaves. Each child
  specification is a map, as shown below:

      children = [
        # The Stack is a child started via Stack.start_link([:hello])
        %{
          id: Stack,
          start: {Stack, :start_link, [[:hello]]}
        }
      ]


        @impl true
        def init(_init_arg) do
          children = [
            {Counter, 0}
          ]

          Supervisor.init(children, strategy: :one_for_one)
