As I was preparing a pull request to fill in some documentation,
I became unsure of a couple of things.
It's clear that the Parameter[1] syntactic element does not
account for the form `InOut(opt) Identifier`, used when the
parameter type is left to inference. However, this form is only
allowed in function/delegate literal expressions, not in
declarations of named functions. So, perhaps adding this form to
Parameter is incorrect, as it's referenced for both. Do we need
to define a new kind of parameter list for FunctionLiteral[2] in
order to account for this extra form?
Further, parameter type inference is implemented in terms of
(anonymous) function templates. However, the documentation only
mentions parameter type inference once, in the following
sentence, under FunctionLiteral[2]:
If the type of a function literal can be uniquely determined
from its context, the[sic] parameter type inference is possible.
Followed by this example:
---
void foo(int function(int) fp);
void test() {
int function(int) fp = (n) { return n * 2; };
// The type of parameter n is inferred to int.
foo((n) { return n * 2; });
// The type of parameter n is inferred to int.
}
---
There is no mention of function templates; is it just an
implementation detail, or something we should document? If we
ever implemented it in some other way, would it not have
consequences for code that can take function templates by alias
and possibly call the same function template several times but
with completely different argument types, which is currently
valid and possibly useful?
[1] http://dlang.org/declaration.html#Parameter
[2] http://dlang.org/expression.html#FunctionLiteral
P.S.
The examples in the language documentation often use widely
inconsistent brace style, and I also found several examples using
capitalization that differs from the Phobos style. Maybe we
should aim to normalize them to use the Phobos style.
