Adam Ruppe:
> void func(Whatever* options = null) {
> if(options is null)
> options = Whatever(default blah blah);
> }
>
> (substitute null for any invalid amount for the parameter. I recently
> did some timezone functions that used int.min as the default offset,
> meaning load it from the global.)
>
> If I want to change the Whatever default, I change it there and it
> still works out. Nothing fancy required.
In ShedSkin (a kind of Python compiler) I plan to do something like that
automatically. The compiler creates a nullable value for each value that has a
default, plus the if+assign inside the function. The nullable is done
compactly, with an extra uint argument that encodes what arguments are actually
given or what ones are not given and need to be initialized inside the function.
So if you write code like this:
void foo(int x, string s="hello", int y=10) {
}
void main() {
foo(1, "red", 2);
foo(3, "green");
foo(4);
}
It is syntax sugar for:
void foo(int x, string s, int y, uint nDefaults) {
if (nDefaults >= 1)
y = 10;
if (nDefaults >= 2)
s = "hello";
}
void main() {
foo(1, "red", 2, 0);
foo(3, "green", int.init, 1);
foo(4, string.init, int.init, 2);
}
This is not exactly like the Python semantics, because in Python default
arguments are set at function definition time (defining a function is an
operation).
Even if this can be acceptable for ShedSkin, probably it's not a good solution
for a almost-system language as D.
-----------------
Brad Roberts:
>Converting these to helpers functions will result in a tiny little function
>that will be inlined, so, right back to the same basic problem.<
I am not sure, but in Scala they can be virtual functions, so the HotSpot
inlines/deinlines them dynamically and as needed to keep the code both fast and
safe all the time.
Thank you for all the answers,
bye,
bearophile
