Elixir and misspelled keyword list options

The NimbleOptions library by Dashbit provides a way to validate Keyword lists by validating the options against a definition. The examples below are from the README.

This library allows you to validate options based on a definition. A definition is a keyword list specifying how the options you want to validate should look like:

definition = [
  connections: [
    type: :non_neg_integer,
    default: 5
  ],
  url: [
    type: :string,
    required: true
  ]
]

Now you can validate options through NimbleOptions.validate/2:

options = [url: "https://example.com"]

NimbleOptions.validate(options, definition)
#=> {:ok, [url: "https://example.com", connections: 5]}

If the options don’t match the definition, an error is returned:

NimbleOptions.validate([connections: 3], schema)
#=> {:error, "required option :url not found, received options: [:connections]"}

I stand corrected.

That’s only lightweight if a function has 1 option, though, especially since keyword lists are ordered. If a function has 4 options you’d probably need tens of function clauses.

The most radical solution, of course, would be to extend def to deal with parsing options:

  def foo(normal, arguments, !some_option = 5, !other_option = 3) do
     # ...
     IO.inspect({normal, arguments, some_option})
  end

But I think the option! macro I suggested would be sufficient.

I built the library Specify for situations where we want to make explicit what options are supported somewhere (and what defaults are used for them).

As for the behaviour of functions built-in to Elixir: I agree that in many cases it would be preferable for the function to crash rather than to silently ignore an unrecognized keyword. In some cases this currently happens but seemingly not everywhere.

That said, if you were to currently write code like this:

defmodule OptionsExample do
  def foo(normal, arguments) do
    foo(normal, arguments, some_option: true)
  end

  def foo(normal, arguments, some_option: some_option) do
     # ...
     IO.inspect({normal, arguments, some_option})
  end
end

then if we were to call it with OptionsExample.foo(10, 20, unexistent: 42) then we will get a FunctionClauseError that highlights what values were passed as well as which function clauses were attempted:

** (FunctionClauseError) no function clause matching in OptionsExample.foo/3    
    
    The following arguments were given to OptionsExample.foo/3:
    
        # 1
        10
    
        # 2
        20
    
        # 3
        [unexistent: 42]
    
    Attempted function clauses (showing 1 out of 1):
    
        def foo(normal, arguments, [some_option: some_option])

Writing code like this is already a very lightweight way to create the behaviour you are suggesting.

I would find that very annoying during development. Often when playing around, I put a spelling mistake in an optional keyword to temporarily disable it (for fiddling around etc.).

This doesn’t need to be a macro, you could implement a function that takes the desired keywords from the list and throws on any unexpected keywords