Private default function arguments

[bearophile]

Time ago I have suggested here (and in the Python newsgroup) to have 
automatically defined inside a function a standard name like __func__ that's an 
alias of the recursive function name it's contained into, this helps avoid 
stating the name of the function two or more times (as the this() constructor 
of D), this keeps the code a little DRYer, so renaming or moving around a 
recursive function gets a bit simpler and cleaner.


Recursive functions have suggested me another little feature (that can not be 
added to Python because of its design) that I think I've not seen elsewhere. My 
recursive functions sometimes need to keep a bit of state, for example an 
integer that keeps the current "depth" of a tree structure that I'm creating or 
scanning, normally in D I can define the function like this:

/// Always use depth=0 at the first call
int foo1(int x, int depth=0) {
  ...
  foo1(x, depth + 1);
  ...
}

The last argument depth must be zero when the function is not called by itself, 
but I must rely on convention and code comments, because the program can't 
avoid errors like:

void main() {
  foo1(10, 5);
}

To be sure to avoid that error I can create a callable struct that keeps depth 
as an attribute (code not tested):

struct foo2 {
  int depth = 0;
  int opCall(int x) {
    ...
  }
}

This foo2 may even be a little faster because less data is passed to the 
function (callable struct) argument.

But another possible solution is to have private default function arguments:

int foo3(int x, private int depth=0) {
  ...
  foo3(x+1); // OK  
  foo3(x, depth + 1); // OK
  ...
}
void main() {
  int r = foo3(5); // OK
  int r = foo3(5, 1); // Error  
  int r = foo3(5, 0); // Error    
}

Now the programmer is allowed to give/specify the "depth" argument only inside 
foo() itself :-)
So the source code comment of foo1() is converted in foo3() into something that 
the compiler can enforce at compile-time.

Bye,
bearophile