It looks like the last time this was discussed was October of 2003, over
the course of about five emails. I don't see anything in the archives
about it since then. Here's what I'd like to suggest.
some_function($a, 'B', :check TRUE)
function some_function($first, $second, :check $key1 = FALSE, :foo $key2)
{
if ($key1) {
lala;
} elseif ($key2 > 0) {
blabla;
}
}
Sticking a : in front of the variable name, either in the calling code or
the function declaration, makes it a keyword argument. Keyword arguments
are always optional, and [could|should] default to something handy like
FALSE or 0. (Maybe make their defaults settable in php.ini?)
I would implement this myself, but even after reading George
Schlossnagle's fantastic book, I'm still not wizardly enough to do so. If
someone could point me in the right direction, though...
Thanks for listening,
Daniel
Daniel Crookston wrote:
some_function($a, 'B', :check TRUE)
function some_function($first, $second, :check $key1 = FALSE, :foo $key2)
First of all: I guess it is too early to start the discussion about
named parameters again.
As much as I think named parameters are an interesting concept I don't
like this solution for its syntax and static semantics.
If you are still interested in what solution we chose here then read
below the line, otherwise please ignore the rest and don't flame me ;-)
I'm still in favor of an approach we are using here where you can pass
associative arrays without array():
some_function($a, "B", 'check' => true);
[ equivalent to some_function($a, "B", array('check' => true)); ]
and use
function some_function($first, $second, $param)
{
if ($param['check'])
...
}
[ or extract($more) inside some_function if you prefer that ].
Patches for php4 and php5 can be found at
http://cschneid.com/php/php4/function_call_named_parameters.patch
and
http://cschneid.com/php/php5/function_call_named_parameters.patch
respectively
There is also a tool called convertsyntax.php at
http://cschneid.com/php/
which converts between old and new syntax.
Have fun,
- Chris
Actually, that would be acceptable, since you lose the bulk of array().
The only thing that remains a problem is that if you add another
(non-named) parameter, you still need to worry about the relative
positions in all of your functions. Now that I think about it, that's
actually a bigger complaint for me than having to use array().
Thoughts? Comments? Flames?
Daniel
P.S. Thank you for the link to the patches :)
I'm still in favor of an approach we are using here where you can pass
associative arrays without array():
<snip all else
Hi Daniel,
named paramters should only be followed by named paramters - like with
default values. So one can first "fill" the unnamed once and then some (or
all) of the named once.
But remembering the last discussion on this idea I don't think this will be
added...
johannes
Daniel Crookston wrote:
Actually, that would be acceptable, since you lose the bulk of array().
The only thing that remains a problem is that if you add another
(non-named) parameter, you still need to worry about the relative
positions in all of your functions. Now that I think about it, that's
actually a bigger complaint for me than having to use array().Thoughts? Comments? Flames?
Daniel
P.S. Thank you for the link to the patches :)
I'm still in favor of an approach we are using here where you can pass
associative arrays without array():<snip all else
function some_function($first, $second, :check $key1 = FALSE, :foo $key2)
PHP 5 supports type hints when writing interfaces for classes.
http://www.zend.com/php5/articles/engine2-php5-changes.php#Heading6
--Dan
--
T H E A N A L Y S I S A N D S O L U T I O N S C O M P A N Y
data intensive web and database programming
http://www.AnalysisAndSolutions.com/
4015 7th Ave #4, Brooklyn NY 11232 v: 718-854-0335 f: 718-854-0409
Even after reading your message twice, I can't think of an example where
this would be useful. Obviously, I don't understand your intention.
Could you give an example of a construction that is made possible by
this feature (and thus would otherwise be impossible)?
Bert
Daniel Crookston wrote:
It looks like the last time this was discussed was October of 2003, over
the course of about five emails. I don't see anything in the archives
about it since then. Here's what I'd like to suggest.some_function($a, 'B', :check TRUE)
function some_function($first, $second, :check $key1 = FALSE, :foo $key2)
{
if ($key1) {
lala;
} elseif ($key2 > 0) {
blabla;
}
}Sticking a : in front of the variable name, either in the calling code or
the function declaration, makes it a keyword argument. Keyword arguments
are always optional, and [could|should] default to something handy like
FALSEor 0. (Maybe make their defaults settable in php.ini?)I would implement this myself, but even after reading George
Schlossnagle's fantastic book, I'm still not wizardly enough to do so. If
someone could point me in the right direction, though...Thanks for listening,
Daniel
Bert Slagter wrote:
Even after reading your message twice, I can't think of an example where
this would be useful. Obviously, I don't understand your intention.
The original poster wants to add syntax for keyword arguments. Keyword
arguments can be found in quite some languages (Python, Common Lisp,
...), they allow you to bind a parameter by name instead of by position
(similar to using an array vs. a hash).
Could you give an example of a construction that is made possible by
this feature (and thus would otherwise be impossible)?
Surely we aren't dealing with Turing completeness here, are we?
Consider the following constructor:
class Window:
def init(title, x=USE_DEFAULT, y=USE_DEFAULT,
width=USE_DEFAULT, height=USE_DEFAULT, parent=None):
pass
And contrast:
window = Window(title='Hello World', width=640, height=480)
with:
window = Window('Hello World', USE_DEFAULT, USE_DEFEAULT, 640, 480)
Cheers,
Michael
Bert
Daniel Crookston wrote:
It looks like the last time this was discussed was October of 2003, over
the course of about five emails. I don't see anything in the archives
about it since then. Here's what I'd like to suggest.some_function($a, 'B', :check TRUE)
function some_function($first, $second, :check $key1 = FALSE, :foo $key2)
{
if ($key1) {
lala;
} elseif ($key2 > 0) {
blabla;
}
}Sticking a : in front of the variable name, either in the calling code or
the function declaration, makes it a keyword argument. Keyword arguments
are always optional, and [could|should] default to something handy like
FALSEor 0. (Maybe make their defaults settable in php.ini?)I would implement this myself, but even after reading George
Schlossnagle's fantastic book, I'm still not wizardly enough to do
so. If
someone could point me in the right direction, though...Thanks for listening,
Daniel
The major benefit of keyword arguments doesn't occur when you're writing
functions, it occurs when you're re-writing them. I can't count the
number of times where I've thought "My xyz function already does something
almost exactly like what I need... if I just passed it an extra parameter,
I could rewrite xyz to do what I need and save a lot of time." So I add
another parameter, making it optional.
This is fine, all the calls to xyz that are lacking the final parameter
still work (since it's optional.) But do this once or twice, and pretty
soon you have function calls that look like this:
xyz('a', 2, $foo, '', '', '', '', '', '', $bar);
That's ugly and unnecessary, and leaves lots of room for bugs when you're
writing functions that use the nth optional parameter in your function
(since you have to count the number of blank spaces you need to leave.)
Additionally, what happens when all of your original, three-argument (a,
2, $foo) calls to xyz need to start passing an additional argument because
of a change you couldn't predict when you first wrote your function?
Keyword arguments solve these problems. They're always optional - not
just optional in that you can stick a '' or NULL in the spot where you
would put a value in the function call. They're optional in that you can
leave them out entirely. Because they're named, they can also be passed
in any order. And, finally, you can add new keyword arguments at any
time, and none of your current function calls will break.
If there's a way to do this in PHP (short of having the last argument be a
hash) that I've missed, please let me know about it.
Daniel Cr
Even after reading your message twice, I can't think of an example where this
would be useful. Obviously, I don't understand your intention.Could you give an example of a construction that is made possible by this
feature (and thus would otherwise be impossible)?Bert
Daniel Crookston wrote:
The major benefit of keyword arguments doesn't occur when you're
writing functions, it occurs when you're re-writing them. I can't
count the number of times where I've thought "My xyz function already
does something almost exactly like what I need... if I just passed it
an extra parameter, I could rewrite xyz to do what I need and save a
lot of time." So I add another parameter, making it optional.This is fine, all the calls to xyz that are lacking the final
parameter still work (since it's optional.) But do this once or
twice, and pretty soon you have function calls that look like this:xyz('a', 2, $foo, '', '', '', '', '', '', $bar);
That's ugly and unnecessary, and leaves lots of room for bugs when
you're writing functions that use the nth optional parameter in your
function (since you have to count the number of blank spaces you need
to leave.)Additionally, what happens when all of your original, three-argument
(a, 2, $foo) calls to xyz need to start passing an additional argument
because of a change you couldn't predict when you first wrote your
function?
all that can be offset by write a complementary set of wrapper functions
like:
function xyzSuperSpecialFooBar($a, $b, $foo, $bar) {
/* using the 7th optional arg - first 3 args required (or whatever) */
return xyz($a, $b, $foo, '', '', '', '', '', '', $bar);
}
which also gives you some nice sugar to help you remember exactly what
that variation of params is supposed to do.
Keyword arguments solve these problems. They're always optional - not
just optional in that you can stick a '' orNULLin the spot where you
would put a value in the function call. They're optional in that you
can leave them out entirely. Because they're named, they can also be
passed in any order. And,
you function is still going to have to do some checking for all these
optional args is it not? whats the great benefit of the optional named
args in any order vs.
passing an array ala:
$arr = array(
'arg1' => 1,
'arg2' => 2,
'arg3' => 4,
);
$rtnV = mySwissArmyKnife($arr);
where :
function mySwissArmyKnife($arr = array()) {
extract($arr);
... do the checking...
... calc something ...
return $x;
}
finally, you can add new keyword arguments at any time, and none of
your current function calls will break.If there's a way to do this in PHP (short of having the last argument
be a hash) that I've missed, please let me know about it.
how about look at the problem in a different way - is the function xyz()
(I assume that you have some realworld situation where this kind of
thing would handy right now) possibly a candidate for spliting up into a
class?
with regard to the 'swiss army knife' function.. have you ever tried to
do any serious construction work with a swiss army knife ;-)
seriously tho, from what I gather there is a icecubes chance is hell
that this will be implemented.
Daniel Cr
Even after reading your message twice, I can't think of an example
where this would be useful. Obviously, I don't understand your
intention.Could you give an example of a construction that is made possible by
this feature (and thus would otherwise be impossible)?Bert