Utilities to make it easier to exract function parameters from keyword lists or maps.

Elixir encourages you to use keyword lists for optional parameters. The problem is that oyu can’t use pattern matching to extract their value, because users expect to be able to supply parameters in any order.

You’re forced to write something like this:

def f(options) do
  a = Keyword.get(options, :a, 1)
  b = Keyword.get(options, :b, 2)
  c = Keyword.get(options, :c, 3)
  d = Keyword.get(options, :d, 4)
  # ...
end

For some (most?) use cases, it would be better if you could write something like this:

def f([a: 1, b: 2, c: 3]) do
  #...
end

which would desuger into the above. This package adds some macros that make it possible. It defines 4 macros:

• Megadef.megadef/2 (expands into Kernel.def/2)
• Megadef.megadefp/2 (expands into Kernel.defp/2)
• Megadef.megadefmacro/2 (expands into Kernel.defmacro/2)
• Megadef.megadefmacrop/2 (expands into Kernel.defmacrp/2)

For example:

  # The `= options` is required; we need an argument name for documentation purposes
  def f(&[a: 1, b: 2, c: 3] = options) do
    # ...
  end

It will expand into:

def f(options) do
  a = Keyword.get(options, :a, 1)
  b = Keyword.get(options, :b, 2)
  c = Keyword.get(options, :c, 3)
  # ...
end

Reference

The megadef macro supports parameter extraction from maps or keyword lists. Both required and optional parameters are supported.

Keyword list with optional parameters:

megadef f(&[a: 1, b: 2] = options) do
  {a, b}
end

If all parameters in the keyword list are optional, you should make the list itself optional:

megadef f(&[a: 1, b: 2] = options \\ []) do
  {a, b}
end

Keyword list with optional and required parameters:

megadef f(&[a, b: 2] = options) do
  {a, b}
end

In this case, you haven’t provided a default value for a. This means that a is a required parameter. The parameter will be fetched by Keyword.fetch!/2 from the keyword list, and if it doesn’t exist it will raise an error.

Internals

These macros use the unary Kernel.&/1 operator. This operator has very low precedence, which means that it encloses the whole argument. For example: &[a: 1, b: 2] = opts \\ [] is equivalent to &([a: 1, b: 2] = opts \\ []). The semantics are backwards-compatible with the semantics inside argument lists of functions defined with Kernel.def/2, because you can’t use &... in a pattern.

If you want, you can redefine def(macro)?(p)? so that they call mdegadef(macro)?(p)?. You probably shouldn’t, though, because it can make your code more confusing to read.