[RFC] Syntax for variadic functions

2013/8/28 Nikita Popov nikita.ppv@gmail.com

Hi internals!

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:

https://wiki.php.net/rfc/variadics

Basically this allows declaring variadics directly in the function
signature, rather than fetching the arguments using func_get_args().
Example:

public function query($query, ...$params) { /* ... */ }

What are your thoughts on this?

+1, primarily because it makes the code self-documented.

However, I would like to hilight one shortcoming of variadic functions
(both with the old and with the proposed syntax): There is no way to call a
variadic function unless all the arguments are hard-coded.

I am extenting the example of the RFC:

class MySQL implements DB {
public function query($query, ...$params) {
// ...
}
public function query_and_log($query, ...$params) {
// this will not work:
$result = $this->query( $query, $params );
log( $query );
return $result;
}
}

Not only this does not work, but there is no way to make it work without
modifying the original function. Would it be possible to extend the RFC
with new syntax that could cover cases like that as well? Maybe something
like that:

$result = $this->query( $query, ...$params );

Other than that, the RFC is very welcome.

Lazare INEPOLOGLOU
Ingénieur Logiciel

Thanks,
Nikita

Hi internals!
Hi Nikita :-),

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:

 https://wiki.php.net/rfc/variadics

Basically this allows declaring variadics directly in the function
signature, rather than fetching the arguments using func_get_args().
Example:

 public function query($query, ...$params) { /* ... */ }

What are your thoughts on this?
Huge +1!
So if we call query('foo'), $params is set to an empty array, right?
Could it be possible to change this behavior? Would it be interesting?
For example: public function query($query, ...$params = null).

Cheers.

--
Ivan Enderlin
Developer of Hoa
http://hoa-project.net/

PhD. student at DISC/Femto-ST (Vesontio) and INRIA (Cassis)
http://disc.univ-fcomte.fr/ and http://www.inria.fr/

Member of HTML and WebApps Working Group of W3C
http://w3.org/

Hi internals!

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:
...

What are your thoughts on this?

I think it's great way to clean things up and add some subtle new
functionality, particularly with Lazare's follow-up proposal about
expanding an indexed array into arguments.

Would any functions get deprecated as a result of this? e.g., func_get_args()

I assume it's a syntax error to do function fn(...$foo, $bar) or
function fn(...$foo, ...$bar)

I assume that function fn($a, $b = null, ...$c) is possible, and the
only way to populate $c is to call fn with three or more parameters.

--
Matthew Leverton

2013/8/28 Nikita Popov nikita.ppv@gmail.com:

Hi internals!

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:

https://wiki.php.net/rfc/variadics

Basically this allows declaring variadics directly in the function
signature, rather than fetching the arguments using func_get_args().
Example:

public function query($query, ...$params) { /* ... */ }

What are your thoughts on this?

Thanks,
Nikita

Using the current variadic functions makes it possible to use 0 or N
arguments, e.g.:

function sum() {
return array_sum(func_get_args());
}

echo sum(10, 5); // echoes 15
echo sum(); // echoes 0

I see nowhere in the RFC whether:

function sum(...$params) { /* */ }

Requires at minimum one argument or none.

I have the feeling that you imply it's minimum one which I would
consider a bit inconsistent with the current "implementation".

Can you please clarify this Nikita?

Thanks

Nikita Popov wrote:

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:

 https://wiki.php.net/rfc/variadics

I can remember in PHP4 days, passing parameters to the database as a string of
variables was the norm. Then arrays came along and it was preferable to pass the
query followed by an array of values. We could take the array and validate the
data in a function, adding any missing values needed before processing the SQL.
Going back to the cumbersum method of working just seems wrong? Surely we should
be promoting a tidier method of working?

--
Lester Caine - G8HFL

Contact - http://lsces.co.uk/wiki/?page=contact
L.S.Caine Electronic Services - http://lsces.co.uk
EnquirySolve - http://enquirysolve.com/
Model Engineers Digital Workshop - http://medw.co.uk
Rainbow Digital Media - http://rainbowdigitalmedia.co.uk

https://wiki.php.net/rfc/variadics 

Interesting idea, expanding on:

function log($message, ...$options) {}

It would seem convenient to allow ...$options to be passed as a key-value array of arguments as well:
function logA($message, ...$options[]) { echo count($options); }

logA("foo"); // 0
logA("foo", 1, 2); // 2
logA("foo", array(1,2,3)); // 3

The difference here is that variadic options is declared as an optional array, it would not support a 'typehint' forcing all arguments to be of the same type.
It could be a way to support ~ named parameters

// requires at least 1 argument named as 'level'
function logB($message, ...$options['level']) {
echo $options['level'] .' '. count($options);
}

logB("foo"); // fails: 'level' argument missing
logB("foo", 'notice'); //notice 1
logB("foo", ['level' => 'notice']); // notice 1
logB("foo", 'notice', 'extra'); // notice 2
logB("foo", ['level' => 'notice'], 'extra'); // notice 2

// requires min 2 arguments
function logC($message, ...$options['level','priority']) {
echo 'level:'. $options['level'];
echo 'priority:'. $options['priority'];
}
logC("foo", "notice", 4);
logC("foo", ['level' => 'notice', 'priority' => 4]);

That would remove the need for a "splat" or "scatter" operator. The declaration "...$options[]" would mean, I accept an array of arguments followed by extra arguments

Hi internals!

I'd like to propose an RFC, which adds dedicated syntax for variadic
functions:

https://wiki.php.net/rfc/variadics

Basically this allows declaring variadics directly in the function
signature, rather than fetching the arguments using func_get_args().
Example:

public function query($query, ...$params) { /* ... */ }

What are your thoughts on this?

I'd like to go forward with voting on this. Are there any issues that still
need to be resolved?

Nikita