On Monday, 27 August 2012 at 00:44:54 UTC, Walter Bright wrote:
On 8/26/2012 4:50 PM, Timon Gehr wrote:
On 08/27/2012 12:41 AM, Walter Bright wrote:
The trouble for function pointers, is that any default args
would need
to be part of the type, not the declaration.
They could be made part of the variable declaration.
You mean part of the function pointer variable?
Consider what you do with a function pointer - you pass it to
someone else. That someone else gets it as a type, not a
declaration. I.e. you lose the default argument information,
since that is not attached to the type.
This problem goes away if the defaults are always the same: the
.init defaults, and if function pointers (but not functions) can
be called with fewer arguments than there are parameters in their
definition. When the call is made, the remaining argument can be
provided using the standard .init defaults.
And because the standard .init defaults can be manipulated via
defining new types for the parameters, it becomes the parameter's
types that the defaults are found from, and defaults do not need
to be encoded in the types of function pointers.
And if you don't like all function pointers getting this
treatment, then it could be extended only to those that are given
a qualification indicating so: one more binary bit added to
mangling of its type.
This mechanism could be made to work equally well with extern(C)
etc. functions.
