     * `{:error, rest}` - there are no switches at the head of the given `argv`
 
   """
-
   @spec next(argv, options) ::
         {:ok, key :: atom, value :: term, argv} |
         {:invalid, String.t, String.t | nil, argv} |

    * `:float` - parses the value as a float
    * `:string` - parses the value as a string

  If a switch can't be parsed according to the given type, it is returned
  in the invalid options list.

  ### Modifiers

  Switches can be specified with modifiers, which change how
  they behave. The following modifiers are supported:

    * `:keep` - keeps duplicated items instead of overriding them; works with
      all types except `:count`. Specifying `switch_name: :keep` assumes the
      type of `:switch_name` will be `:string`.

  Note that if you want to use `:keep` with a type other than `:string`, use a list
  as the type for the switch. For example: `[foo: [:integer, :keep]]`.

  ### Negation switches


      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
      {[op: false], ["path/to/file"], []}

  ### Parsing dynamic switches

  `OptionParser` also includes a dynamic mode where it will attempt to parse
  switches dynamically. Such can be done by not specifying the `:switches` or
  `:strict` option.

      iex> OptionParser.parse(["--debug"])
      {[debug: true], [], []}


  Switches followed by a value will be assigned the value, as a string. Switches
  without an argument, like `--debug` in the examples above, will automatically be
  set to `true`.

  Since Elixir converts switches to atoms, the dynamic mode will only parse
  switches that translates to atoms used by the runtime. Therefore, the code below
  likely won't parse the given option since the `:option_parser_example` atom is
  never used anywhere:

      OptionParser.parse(["--option-parser-example"])
      # Does nothing more...

  However, the code below does since the `:option_parser_example` atom is used
  at some point later (or earlier) on:

      {opts, _, _} = OptionParser.parse(["--option-parser-example"])
      opts[:option_parser_example]

  In other words, when using dynamic mode, Elixir will do the correct thing and
  only parse options that are used by the runtime, ignoring all others. If you
  would like to parse all switches, regardless if they exist or not, you can
  force creation of atoms by passing `allow_nonexistent_atoms: true` as option.
  Such option is useful when you are building command-line applications that
  receive dynamically-named arguments but must be used with care on long-running
  systems.

  Switches followed by a value will be assigned the value, as a string.
  Switches without an argument, like `--debug` in the examples above, will
  automatically be set to `true`.

  ## Aliases

