[swift-evolution] [Draft] Allow trailing commas in argument lists

[Rainer Brockerhoff]

I continue to be in favor of trailing commas in arrays and enums, but
agree that for method/functions signatures and calls it's not so good.

However, in analogy to `;`s to separate statements on the same line, it
might be useful to consider commas in a similar light; that is, commas
would be required to separate arguments on the same line, but become
optional in multi-line statements. So:

     let person = Person(
        id: json['id']
        name: json['name']
        picture: Im2age(picture)
        friends: friends
     )
but
	let person = Person(id: json['id'], name: json['name'], picture:
Im2age(picture), friends: friends)


On 3/14/16 12:08, Tim Schmelter via swift-evolution wrote:
> -1
> 
> If we agree with the Swift API Guidelines: "Clarity at the point of use is
> your most important goal", it seems to me that adding trailing commas to a
> method/function signature reduces clarity significantly, with others on
> this thread and the previous articulating the supporting reasons.
> 
> As an aside: I also eschew trailing commas in array declarations, but
> recognized that this convention is well established in other languages, and
> am resigned to letting the linter handle that case. I would look to do that
> in this case as well.
> 
> --T
> 
> 
> On Tue, Mar 8, 2016 at 2:07 PM, Grant Paul via swift-evolution <
> swift-evolution at swift.org> wrote:
> 
>> ## Introduction
>>
>> Right now, Swift argument lists are not permitted to contain trailing
>> commas. To make multi-line calls easier, we propose allowing trailing
>> commas in argument (and tuple) syntax:
>>
>>     let person = Person(
>>        id: json['id'],
>>        name: json['name'],
>>        picture: Im2age(picture),
>>        friends: friends,
>>     )
>>
>>
>> ## Motivation
>>
>> It’s common for functions to take a number of arguments. In some
>> languages, this can make it difficult to figure out what a function does,
>> leading to patterns like fluent interfaces and configuration objects.
>>
>> Swift, by contrast, handles this very well. Argument labels make sure
>> parameters aren’t confused even when they’re of the same type. And compared
>> to Objective-C, it’s much easier to write a multi-line list of arguments in
>> Swift.
>>
>> However, with a parentheses placement style placing the closing
>> parentheses for a multi-line call on a new line, Swift does not support a
>> trailing comma. Trailing commas have a number of benefits:
>>
>>  - It is easier to re-arrange lines (especially in certain text editors)
>> when all lines have commas.
>>  - Line-based diffs (as used by most source control systems) only show
>> added lines when adding a new parameter to the end, rather than two lines
>> where one just adds the comma.
>>  - It’s more consistent with other Swift lists which do support trailing
>> commas.
>>
>>
>> ## Proposed Solution
>>
>> The proposed solution is to allow and ignore trailing commas in argument
>> lists and tuples:
>>
>>     let person = Person(
>>         id: json['id'],
>>         name: json['name'],
>>         picture: Image(picture),
>>         friends: friends,
>>     )
>>
>>     let tuple = (
>>        color,
>>        32,
>>     )
>>
>>
>> ## Detailed Design
>>
>> Support for trailing commas in argument lists and tuples would make them
>> consistent with Swift’s handling of array literals, which do support
>> trailing commas:
>>
>>     let array = [
>>         2,
>>         4,
>>         8,
>>     ]
>>
>> There should not be any impact to existing code from this proposal.
>>
>> Support for this syntax is also found in other programming languages like
>> Python, D, and Hack. It’s been proposed for JavaScript (positive response)
>> and PHP (rejected):
>>
>>  - JavaScript: https://jeffmo.github.io/es-trailing-function-commas/
>>  - PHP: https://wiki.php.net/rfc/trailing-comma-function-args
>>
>>
>> ## Alternatives Considered
>>
>> The main alternative is the existing behavior. This has the benefit of
>> standardizing Swift code on a particular style. However, many people will
>> in practice continue to use a style regardless of support trailing commas,
>> especially for cross-language consistency. It could also lead to
>> JavaScript-inspired parameter ordering:
>>
>>     let person =
>>         Person(id: json['id']
>>              , name: json['name']
>>              , picture: Image(picture)
>>              , friends: friends)
>>
>> Another alternative would be to support this syntax for function
>> parameters but not tuples. However, this would be an arbitrary
>> inconsistency.
>>
>> _______________________________________________
>> swift-evolution mailing list
>> swift-evolution at swift.org
>> https://lists.swift.org/mailman/listinfo/swift-evolution
>>
> 
> 
> 
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
> 


-- 
Rainer Brockerhoff  <rainer at brockerhoff.net>
Belo Horizonte, Brazil
"In the affairs of others even fools are wise
In their own business even sages err."
http://brockerhoff.net/blog/