Named arguments revisited

I have to admit, although you could do it other ways, it wouldn't be as
clean as what you're proposing. Especially handy for when you just want
to pass on that last parameter without having to pass on all the
forgoing parameters. I'd consider it a nice-to-have.

As for the syntax. I'd like to propose it as follows (syntax-wise):

somefunction($var, $var2, $var3, $var4 = 'val4', $var5) {}

Syntax for calling it with named arguments:

somefunction($var3 = 'val3', $var5 = $othervar = 'val5');

Or it may be confusing to use '$' in front of the names. (I was looking
for consistency with the way you define a function.) So perhaps like this:

somefunction(var3 = 'val3', var5 = $othervar = 'val5');

Only now I'm wondering. Since the PHP engine would have to check for
named arguments for each function. Wouldn't this performancewise cause
too much overhead on function calls?

Ron Korving wrote:

You could use an associative array, but then you have a not-so-clean syntax
and you have to handle default values for missing parameters yourself.

Named parameter example:

<?php
function adduser(username: $username, password: $password, superuser:
$superuser=false)
{
// now do some stuff with $username, $password and $superuser
}

adduser('root', 'abcdefg', true);
// or:
adduser(username: 'root', password: 'abcdefg', superuser: true);
?>

Traditional named example:

<?php
function adduser($params)
{
if (!is_array($params)) throw new Exception('No named parameters');
if (!isset($params['username'])) throw new Exception('Missing parameter:
username');
if (!isset($params['password'])) throw new Exception('Missing parameter:
username');
if (!isset($params['superuser'])) $params['superuser'] = false;

// now do some stuff with $params

}

adduser(array('username' => 'root', 'password' => 'abcdefg', 'superuser'
=> true));
?>

You see the big advantages of named parameters?

• clean syntax

• no array handling inside the function or method

• no checking on the existance or non-existance of parameters

• no forcing default values for missing parameters

• when you need to skip a parameter, you no longer have to give it's default
  value when calling the function, you can simply skip the whole parameter:

  function foo(bar: $bar=0, bla: $bla='test', cow: $moo='moooo');

call:
foo(cow: 'test');
foo(0, 'test', 'test');

Named parameters would kick serious butt :)

• Ron

"Bart de Boer" bart@mediawave.nl schreef in bericht
news:2D.57.14828.3453E834@pb1.pair.com...

Hi Jared,

If probably don't understand named arguments correclty but couldn't you do
something like:

function(array('name1' => 'val1', 'name2' => $var));

In the function you could then check which keys (names) have values,
thereby simulating a form of named agruments?

Named arguments are absolutely essential for using PHP as a solid
templating language, and, in fact, they also greatly enhance code
readability for complex method calls of in-depth APIs. My experience
with both Objective-C and Python has showed me the wonders and joys of
named arguments, and it is something I've desperately wanted in PHP for
ages. I'm sure I'm not alone in this. I've tried array constructs,
multiple arguments with string-based names and fancy parsing using
func_get_args(), and various combinations thereof, and nothing is a good
substitute for the real deal.

Ron Korving wrote:

Named parameter example:

Your example misses the main advantage of named parameters IMHO: Sets of
parameters you don't want to or can't explicitely list because they are
not know yet.

function adduser($params)
{
if (!is_array($params)) throw new Exception('No named parameters');
if (!isset($params['username'])) throw new Exception('Missing parameter:
username');
if (!isset($params['password'])) throw new Exception('Missing parameter:
username');
if (!isset($params['superuser'])) $params['superuser'] = false;

// now do some stuff with $params

}

adduser(array('username' => 'root', 'password' => 'abcdefg', 'superuser'
=> true));

This is not how we use named parameters at all. If you have a finite set
of fixed parameters then positional parameters are working just fine.

One of the main advantages lies in a catch-all parameter which gets all
unassignable parameters. While this opens the door for typos even a
whips'n'chains language like Python added this feature because it is
just too useful to omit if you have named parameters :-)

Our use case is something along the lines of (not the actual code, so
don't comment on anything specific here ;-)):

function tag($name, $p = array())
{
foreach ($p as $key => $value)
{
if (is_int($key))
$content .= $value;
else
$attributes .= " $key='$value'";
}

return "<$name$attributes>$content</$name>";

}

function a($p = array())
{
return tag("a", $p);
}

...

echo a(array('href' => $url, 'title' => $title));
or with our patch to make array() obsolete
echo a('href' => $url, 'title' => $title);

Now something like
echo a(href: $url, title: $title, 'non-identifier-chars': 42);
would be even neater, agreed ;-)

• Chris

Hello Aidan,

I think named parameters would be a useful feature... I'll leave it
at that.

Here is a coding idea for you, in case you hadn't considered it...

function highlight($text=NULL, $needle=NULL, $strip_links=NULL, ...)
{
is_null($text) && $text = SOME DEFAULT VALUE;
is_null($needle) && $text = SOME DEFAULT VALUE;
is_null($strip_links) && $text = SOME DEFAULT VALUE;
...
}

In that way, the user doesn't have to remember the default values,
just the offsets.

Best wishes with the proposal.

--
Best regards,
Jason mailto:jason@ionzoft.com

Wednesday, January 11, 2006, 8:53:11 PM, you wrote:

AL> Andrei Zmievski wrote:

As useful functions tend to increase in complexity over time, often so
does the number of parameters.

It soon gets to the point where function calls look like:
foo(true, false, false, false, false, true)
The rest of the parameters being required to be supplied, with their
default value, when the user is only interested in changing the last
option.

If you get to the point where your function has a dozen parameters, I
would suggest re-thinking the purpose and design of such a function,
because you are likely trying to make it do too much.

-Andrei

AL> In a simple highlighting function I wrote (which at 16k hits is probably
AL> considered useful) I needed most of the following parameters:

AL> $text
AL> $needle
AL> $strip_links
AL> $case_sensitive
AL> $whole_word_only
AL> $simple_text_only
AL> $highlight_pattern
AL> $return_or_print
AL> $use_xhtml
AL> $tooltips_or_divs

AL> I imagine any function dealing with html may use a significant portion
AL> of these. Obviously some of these are for effect, but I think my point
AL> is clear enough.

AL> We've discussed other options at developers disposal like associative
AL> arrays, setOpt and getOpt functions in a class, but again each have
AL> their drawbacks and named parameters solve the problem elegantly.

AL> Could we properly discuss the pros and cons of a name parameters
AL> implementation - even if it's only to put the whole issue to bed once
AL> and for all?

AL> Best wishes,
AL> Aidan

Hello Jared,

JW> PHP is all about using a simple means to an end and getting the job
JW> done. Named parameters makes coding easier, not harder.

Well stated.

--
Best regards,
Jason mailto:jason@ionzoft.com