The top-level body-less function clause in a multi-head function
is currently used for defining default argument values,
and argument names for doc.

There are two kinds of guards:

• Type-level guards that enforce the argument types for all function clauses.
• Guard-matching clauses that select amongst function bodies.

It is tiresome and error-prone to duplicate type-level guards in every specific function head. It also clutters the guards, and makes it difficult to distinguish the type-level enforcement and the selective guards.

I propose the language is changed to allow guards on the body-less top-level function head. These would be the type-level guards to be applied as a precondition before any other function clause is matched, or perhaps ANDed with every other function clause to let the Erlang guard/pattern compiler factor out the common guards to the front of the match execution.

I have had this desire for some time, but what triggered this post and suggestion is seeing this in the Stream implementation:

  def take(enum, count) when is_integer(count) do
    take_after_guards(enum, count)
  end

  defp take_after_guards(_enum, 0), do: %Stream{enum: []}

  defp take_after_guards([], _count), do: %Stream{enum: []}

  defp take_after_guards(enum, count) when count > 0 do
    lazy(enum, count, fn f1 -> R.take(f1) end)
  end

  defp take_after_guards(enum, count) when count < 0 do
    &Enumerable.reduce(Enum.take(enum, count), &1, &2)
  end

Obviously someone else has had the same thought.

With my suggestion, the above code would become:

  def take(enum, count) when is_integer(count) 

  def take(_enum, 0), do: %Stream{enum: []}

  def take([], _count), do: %Stream{enum: []}

  def take(enum, count) when count > 0 do
    lazy(enum, count, fn f1 -> R.take(f1) end)
  end

  def take(enum, count) when count < 0 do
    &Enumerable.reduce(Enum.take(enum, count), &1, &2)
  end

- Fire Dragon