<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><br class=""><div><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class="">We believe fairly strongly that Swift’s design here reflects the appropriate defaults for clear, expressive APIs and code. The API Design Guidelines line up with the default behavior of Swift for a reason. Repeating the “Objective-C legacy” trope strongly implies that you’re not considering the rationale behind Swift’s design, and weakens your arguments considerably.</div></div></div></div></blockquote>I'm not saying the influence of Objective-C is bad (therefore, I used the quotation marks), but imho it's pointless to deny that it exists.<br class=""><div><br class=""></div><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class=""><div style="margin: 0px; font-size: 11px; line-height: normal; font-family: Menlo;" class="">say(message: <span style="font-variant-ligatures: no-common-ligatures; color: #d12f1b" class="">"Hello"</span>, times: <span style="font-variant-ligatures: no-common-ligatures; color: #272ad8" class="">4</span>)</div></div></div></div></div></blockquote><div class=""><br class=""></div><div class="">The message is the direct object of the verb “say”, so the first argument being the message is implied. Clarity is not improved by having the “message:” argument label.</div></div></div></div></blockquote>I wouldn't force anyone to use that label — and I think this topic was not started because of a lack of clarity, but an excess of different rules.<br class=""><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class=""><span class="" style="color: rgb(209, 47, 27); font-family: Menlo; font-size: 11px;">say(</span><span style="color: rgb(209, 47, 27); font-family: Menlo; font-size: 11px;" class="">"Hello"</span><span class="" style="color: rgb(209, 47, 27); font-family: Menlo; font-size: 11px;">, </span><span class="" style="font-family: Menlo; font-size: 11px; color: rgb(39, 42, 216);">4</span><span class="" style="color: rgb(209, 47, 27); font-family: Menlo; font-size: 11px;">)</span></div></div></div></div></blockquote><div class=""><br class=""></div><div class="">This is less clear than your initial example. There is absolutely nothing to indicate, at the call site, that “4” is a repeat count.</div></div></div></blockquote><div>Here as well: The use of a label should not be discouraged — but you can't fight against users who (for whatever reason) want to use calls that are hard to understand.</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class="">Labels are "just" an aid for programmers, but for the program itself, they have not much more meaning than a comment:</div></div></div></div></blockquote><div class=""><br class=""></div><div class="">That is incorrect. The argument labels are a fundamental part of the name of a Swift function (or initializer, or subscript).</div></div></div></blockquote><div>I guess that sentence failed in expressing my thoughts:</div><div>Of course, labels have influence on method/selector resolution — but their raison d'être is to help programmers to write calls that are easy to understand: Many languages have no labels for parameters, and afair, there has been at least one bridge (Cocoa for Java?) that had to get rid of them. </div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class="">Higher-order functions already ignore labels completely and rely on positions only.</div></div></div></div></blockquote><div class=""><br class=""></div><div class="">That’s mostly correct; our model around argument labels with function types is fuzzy and needs work.</div></div></div></blockquote><div><br class=""></div><div>Taking a statement from another thread:</div><blockquote type="cite" class="">Right now, you'll still need to use labels in the call. However, this is an area where we'd like to revisit things a bit: having labels in function types seems to cause more trouble than it provides benefits, and I'd like to see up address that directly.</blockquote><div class="">So you say that there are situations where labels are bad, right? So it would be necessary to define rules on how to get rid of them as well...</div><div class=""><br class=""></div><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class="">So, instead of complicated rules enforced by the compiler, I would prefer a simple system backed by conventions that discourage programmers to fall back to C-style calls where you have to count parameters to decipher their meaning.</div></div></div></div></blockquote><br class=""></div><div class="">So… you want a plethora of conventions that differ from one project to the next,</div></div></blockquote><div>No. I don't think there would be an urge to establish a different set of conventions for each project/team.</div><br class=""><blockquote type="cite" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">rather than a set of default language rules backed by the API Design Guidelines? I admit that one will often do a double-take when first encountering the rules for which arguments have labels by default, but I’d rather learn that once than have widely differing approaches to when argument labels are provided vs. dropped.</div></div></blockquote>I think you are underestimating the importance of conventions — in the area of code comprehensibility, they are far more powerful than anything that can be enforced by a compiler.</div><div><br class=""></div><div>There has been another discussion about something that's optional and should become mandatory (self). I'm glad that proposal was rejected, as I think it's not that hard to define a set of guidelines when to use "self." and when to skip it, but it shouldn't be the job of the compiler to enforce rules whose only justification is to make source more accessible to human readers.</div><div>Imho labels are very similar in this aspect, with the difference that right now, there is a quite complicated scheme embedded in the compiler. Moving that responsibility to the party that actually is affected by the choice (we as developers) would make the language simpler and more elegant.</div><div><br class=""></div><div>Tino</div></body></html>