It would be nice if there was some character like $ or something, if used as
function argument, the default value for this argument to be used. What I mean
is this:
void myfun(int a,char[] b,bool d=false,int e=55){}
void main()
{
myfun(5,"5",$,$); // which should act like myfun(5,"5",false,55);
}

It would be nice if there was some character like $ or something, if used as
function argument, the default value for this argument to be used. What I mean
is this:
void myfun(int a,char[] b,bool d=false,int e=55){}
void main()
{
myfun(5,"5",$,$); // which should act like myfun(5,"5",false,55);
}

It would be nice if there was some character like $ or something, if
used as function argument, the default value for this argument to be
used. What I mean is this:
void myfun(int a,char[] b,bool d=false,int e=55){}
void main()
{
myfun(5,"5",$,$); // which should act like myfun(5,"5",false,55);
}

We already have the perfect keyword for this: default.
void main()
{
myfunction(5, "5", default, false);
}
A little more verbose, but pretty self-explanatory as to what it does.
Also, keep in mind that "$" already means array length inside of a
slice; I think it would be a bad idea to overload it with a completely
different meaning.
On a side note, you can do something vaguely similar using templated
functions and "typedef int DefaultType; const Default =
DefaultType.ini;" like so:
const int e_default = 55;
void myfunction(T)(T _e=Default)
{
static if( is( T == DefaultType ) )
e = e_default;
else
e = e;
}
Or somesuch; been a while since I did that :)
-- Daniel
--
int getRandomNumber()
{
return 4; // chosen by fair dice roll.
// guaranteed to be random.
}
http://xkcd.com/
v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D
i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/

It would be nice if there was some character like $ or something, if used as
function argument, the default value for this argument to be used. What I mean
is this:
void myfun(int a,char[] b,bool d=false,int e=55){}
void main()
{
myfun(5,"5",$,$); // which should act like myfun(5,"5",false,55);
}

While some languages provide named parameters, they tend to be langs
which encourage functions with many arguments. If you find you are
creating functions like this, you should first ask yourself if this is
the best way. If you decide that it is, one pattern to use is analogous
to the Builder pattern:
struct myFunArgs
{
int a;
char[] b;
bool d = false;
int e = 55;
}
void myfun(myFunArgs args) { ... }
myFunArgs args;
args.a = 5; args.b = "5";
myfun(args);
This is the *very* Poor Man's named parameters mechanism, but if you
have enough parameters to need named ones, then this probably isn't at
all burdensome (and may increase clarity).
Another alternative, if you are creating a library function that you
want to be *very* friendly, you can create a variadic type-safe template
function and parse the args inside the function (though this doesn't
work very well with args of the same type). Of course, you can use the
Perl convention of name, value pairs to make it completely general, but
that's not very elegant or idiomatic D style.
Dave

It would be nice if there was some character like $ or something, if used as
function argument, the default value for this argument to be used. What I mean
is this:
void myfun(int a,char[] b,bool d=false,int e=55){}
void main()
{
myfun(5,"5",$,$); // which should act like myfun(5,"5",false,55);
}

While some languages provide named parameters, they tend to be langs which
encourage functions with many arguments. If you find you are creating
functions like this, you
should first ask yourself if this is the best way. If you decide that it is,
one pattern to use is analogous to the Builder pattern:
struct myFunArgs
{
int a;
char[] b;
bool d = false;
int e = 55;
}
void myfun(myFunArgs args) { ... }
myFunArgs args;
args.a = 5; args.b = "5";
myfun(args);
This is the *very* Poor Man's named parameters mechanism, but if you have
enough parameters to need named ones, then this probably isn't at all
burdensome (and may increase
clarity).
Another alternative, if you are creating a library function that you want to
be *very* friendly, you can create a variadic type-safe template function and
parse the args
inside the function (though this doesn't work very well with args of the same
type). Of course, you can use the Perl convention of name, value pairs to make
it completely
general, but that's not very elegant or idiomatic D style.