This is an old revision of the document!

PHP RFC: Trailing Commas In List Syntax


Per the feedback on the internals list, this RFC broadens the scope of the original RFC to allow trailing commas in function arguments to all list syntax.

Arrays in PHP have long since supported trailing commas.

Trailing array commas

$foo = [

This makes for clean diffs and easy appending of new values in user-land.

Unfortunately, the other lists do not share the same luxury.

Raises a parse error



This RFC proposes allowing trailing commas in all list syntax in order to:

  1. Offer a consistent API and match the existing array functionality.
  2. Make it easy to append new elements to a list in user-land.
  3. Have cleaner diffs (so only one line shows up as being modified when appending elements instead of two).
  4. It makes code reviews a tiny bit faster and for really large codebases, that time adds up. (Sara Golemon explained why HHVM added the trailing comma syntax.)

The following lists would allow trailing commas:

  1. Grouped namepaces
  2. Function/method arguments (declarations & calls)
  3. Interface implementations on a class
  4. Trait implementations on a class
  5. Class member lists

Marcio Almada posted a gist with examples of trailing commas for the various lists (shown below):

Trailing commas for all lists

// Grouped namepaces
use Foo\Bar\{ Foo, Bar, Baz, };
// Arrays (already possible)
$array = [1, 2, 3,];
// Function/method arguments (call)
fooCall($arg1, $arg2, $arg3,);
class Foo implements
    // Interface implementations on a class
    // Trait implementations on a class
    // Class member lists
        A = 1010,
        B = 1021,
        C = 1032,
        D = 1043,
        $a = 'foo',
        $b = 'bar',
        $c = 'baz',
    // Function/method arguments (declaration)
    function something(FooBarBazInterface $in, FooBarBazInterface $out,) : bool

Discussion Points

There are a number of questions that have already been discussed on the internals list.

How will it work with variadics?

PHP allows for multiple splats in one call so trailing commas would work the same way.


Why allocate resources to make this happen

The actual implementation for adding tailing commas to function arguments/calls is two lines. Implementing the functionality to all lists would not require many more changes to the php-src codebase.

You could just use leading commas

function foo(
) { ... }
  1. Leading commas would break away from PSRs
  2. Parsing leading commas cause cognitive overhead whereas standard practice calls for trailing commas

The arguments for & against are weak


  • For it: It's handy. (And the reasons detailed above).
  • Against: It's ugly. There are only minor gains.

Backward Incompatible Changes

This change would have no breaking changes.

Proposed PHP Version

PHP 7.1

Proposed Voting Choices

Each trailing comma list syntax would get its own vote and would require a 2/3 majority to pass.

  1. Function/method arguments (declarations & calls)
  2. Grouped namepaces
  3. Interface implementations on a class
  4. Trait implementations on a class
  5. Class member lists

Patches and Tests

rfc/list-syntax-trailing-commas.1446578083.txt.gz · Last modified: 2017/09/22 13:28 (external edit)