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
