On Monday, 27 August 2012 at 12:14:30 UTC, Manu wrote:
On 27 August 2012 14:08, Carl Sturtivant <sturtiv...@gmail.com>
wrote:
extern(C) void function( ref const(Vector2) v0, ref
const(Vector2) v1,
ref const(Vector2) v2, ref const(Color) color = Color.white,
BlendMode
blendMode = BlendMode.Disabled ) fillTriangle2D;
If function pointers could be called with fewer than the
prototypical
number of arguments, and the remaining arguments be always
initialized to
their .init defaults, you could perhaps make this sort of
thing work
without the default argument values by using struct defaults.
How would that be deficient?
... no.
Color does not .init == Color.white. You're suggesting I define
a new type,
obscuring the API, every time I want a non-.init default arg?
Also, I think it's correct that functions shouldn't be callable
without
explicit parameters. Default args are carefully selected, and
they are
always opt-in.
'v2' in this case shouldn't be allowed to default to [ NaN, NaN
] if I omit
it.
More specifically, you can get the default initialization of e.g.
double to be different as follows.
import std.stdio;
struct dbl(double init) {
double d = init;
alias d this;
}
void main() {
dbl!3.142 x;
dbl!2.0 y;
writeln(x*y);
}
In the case of an external(C) struct, the D definition can fix up
its own default initialization without a new type name even.
Color for example could be fixed up to initialize to Color.white
by default.
And, having the compiler fix up omitted trailing arguments with
.init default values could be confined to "opt-in" parameters by
a small change to the type system for function pointers as
follows.
The type of a function pointer could now include the number of
trailing parameters that may be defaulted. This does not explode
the size of a mangled name much. A syntactic mechanism to
indicate which trailing parameters may be defaulted in a function
prototype could be added to D. The default would be none with
functions declared without that mechanism. This mechanism needs
to be a part of the prototype so that it can be used on
external(C) functions etcetera.
Now only trailing parameters that you intend to be defaulted
would would get defaulted with the .init treatment. Others would
be compilation errors.
Now what's wrong with this if there are no trailing argument
defaults except for the .init defaults?
