<div dir="ltr"><div><br></div><div>The topic of this thread:</div><div>It is simply the history and future of parentheses in Swift. My initial post is just a starting point, it could have been something else. But I'm interested to hear what people have to say about the history and future of Swift's parentheses.</div><div><br></div><div>What is messy:</div><div>As I said, many things parentheses-related in Swift are (at least currently) messy: tuples, func calling, -definitions, -signatures, -types, discussions about them, etc. </div><div><br></div><div>It's hard to discuss (and probably design) a system in which parentheses are used for so many different but intertweaved concepts (is there a complete list of all the uses for parentheses in Swift?).</div><div><br></div><div>There are many concrete examples of this parentheses-related "mess", namely bugs and/or inconsistencies. See for example the four bugs I was just recently asked to file in this thread:</div><div><a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170605/037049.html">https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170605/037049.html</a></div><div><br></div><div>Similar inconsistencies and bugs have been in Swift since the first beta.</div><div><br></div><div>Why are they still there? Why does it take so long to get rid of them?</div><div><br></div><div>Again, I think part of the problem is that the multipurpose parentheses confuses people and also makes it necessary to add special rules to handle clashes in the syntax which would perhaps not have been there if parentheses hadn't been used for so many different things.</div><div><br></div><div>Don't know if that clarified anything or if I'm just repeating myself. </div><div><br></div><div>I'm not seeking to discuss any particular kinds of cleaning up, just interested to hear anything people think about related to parentheses in Swift (tuples, paramter lists, argument lists, pattern matching, ...).</div><div><br></div><div>/Jens</div><div><br></div><div class="gmail_extra"><br><div class="gmail_quote">On Sat, Jun 10, 2017 at 2:00 AM, Xiaodi Wu <span dir="ltr"><<a href="mailto:xiaodi.wu@gmail.com" target="_blank">xiaodi.wu@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr">I'm confused as to the topic of this thread:<div><br></div><div>On the one hand, you're starting off with a statement about parentheses being used for multiple different things, suggesting that what you want to discuss is related to spelling using parentheses.</div><div><br></div><div>OTOH, the exercises that you put forward show that you're concerned about the loss of implicit tuple splatting, a well-acknowledged regression, for which the way forward is to introduce explicit tuple splatting at some point in the future (at least, according to SE-0029, that's the intended direction for Swift).<div><br></div><div>What, in the end, are you claiming to be "messy," and what kinds of cleaning up are you seeking to discuss?</div></div><div><br></div><div><br></div></div><div class="HOEnZb"><div class="h5"><div class="gmail_extra"><br><div class="gmail_quote">On Fri, Jun 9, 2017 at 7:34 PM, Jens Persson via swift-evolution <span dir="ltr"><<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div>The analogy of the special first parameter label was relevant (for me) in that it was a special rule that was invented to resolve a problem/situation with no clear best solution. Probably most people agree now that the current simpler and more uniform rule set for parameter labels are obviously better. It was possible to escape the ugly special case of the first parameter, after all.</div><div><br></div><div>Similarly, I wonder if the parentheses-related mess actually can be simpler and more uniform, after all. I remember a lot of discussions in which people argued that Swift couldn't and/or shouldn't get rid of the special first parameter label rules.</div><div><br></div>I'm not a compiler hacker and I have no idea exactly what aspects of the language is easy/hard/impossible to change once Swift is binary stable.<div><br><div>My concrete concerns are that the messy parentheses-related parts of the language will continue to be messy for ever.</div><div>I have no idea if there is any actual reason to worry about that, but ABI stability was originally intended for Swift 3, and then it was postponed because some stuff needed to be done before ABI stability. Now I'm just worried that solving the parentheses situation is something that needs to be done before ABI stability. Please correct/enlighten me!</div></div><span class="m_1761630961748148602HOEnZb"><font color="#888888"><div><br></div><div>/Jens</div><div><br></div><div><br></div></font></span></div><div class="m_1761630961748148602HOEnZb"><div class="m_1761630961748148602h5"><div class="gmail_extra"><br><div class="gmail_quote">On Sat, Jun 10, 2017 at 12:50 AM, Michael Ilseman <span dir="ltr"><<a href="mailto:milseman@apple.com" target="_blank">milseman@apple.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="auto"><div><div class="m_1761630961748148602m_1730409288391348670h5"><div><br></div><div><br>On Jun 9, 2017, at 2:10 PM, Jens Persson via swift-evolution <<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a>> wrote:<br><br></div><blockquote type="cite"><div><div dir="ltr">The point of exercise 1 is to show that it is impossible (in Swift 4) to write a generic function composition operator (or function) which works as expected for any reasonable functions.<div>This was possible in Swift 3, but in Swift 4 it will only work for functions with exactly one parameter. You'd have to special-case it for every combination of parameter counts of f and g that it should be able to handle.<br><div><br></div><div><div>The following program demonstrates how it can be done in Swift 3.1 and 3.2:</div><div><br></div><div>func compose<T, U, V>(_ g: @escaping (U) -> V, _ f: @escaping (T) -> U) -> (T) -> V {</div><div> return { x in g(f(x)) }<br></div><div>}</div><div>func sum(_ a: Int, _ b: Int) -> Int { return a + b }</div><div>func square(_ a: Int) -> Int { return a * a }</div><div>let squaredSum = compose(square, sum)</div><div>let result = squaredSum((3, 4)) // A bit unexepected with a tuple here but ok ...</div><div>print(result) // 49</div><div>// Well, it worked, not flawlessly but we did manage to write</div><div>// a function composition function and we composed sum</div><div>// and square, and we could call it and get a correct result.</div><div><br></div><div> </div><div>And this program demonstrates what happens if you try it in Swift 4:</div><div><br></div><div>func compose<T, U, V>(_ g: @escaping (U) -> V, _ f: @escaping (T) -> U) -> (T) -> V {</div><div> return { x in g(f(x)) }</div><div>}</div><div>func sum(_ a: Int, _ b: Int) -> Int { return a + b }</div><div>func square(_ a: Int) -> Int { return a * a }</div><div>// let squaredSum = compose(square, sum) // Error! (without the compose-variant below)</div><div><br></div><div>// The error message is:</div><div>// Cannot convert value of type `(Int, Int) -> Int` to</div><div>// expected argument type `(_) -> _`</div><div><br></div><div>// That's it, it is simply not possible!</div><div><br></div><div>// You'd have to write special variants of the compose func for every combination</div><div>// of parameter counts! For example, in order to get this sum and square</div><div>// example working, this specific variant must be written:</div><div>func compose<T, U, V, W>(_ g: @escaping (V) -> W, _ f: @escaping (T, U) -> V) -> (T, U) -> W {</div><div> return { (x, y) in g(f(x, y)) }</div><div>}</div><div>// Now it will work:</div><div>let squaredSum = compose(square, sum)</div><div>// But only thanks to that awfully specific compose func variant ...</div></div><div>// We would have to write a lot more variants for it to be practically usable on pretty much any common function.</div><div><br></div><div>I'm sure some will say:</div><div>"no regular developers use function composition anyway so why ..."</div><div>or</div><div>"It's not very swifty to use free functions and higher order functions like that."</div><div><br></div><div>My answer is that this is just a simple but telling example. The issue (as I see it) exists in all situations involving generics and function types.</div><div><br></div><div>I'm a regular programmer and I like to be able to write basic, useful abstractions.</div><div>It's no fun when the language forces you to write lots of specific variants of your generic code.</div><div><br></div><div>I would feel less worried about the parentheses situation if the language was going in a direction where you could see how this simple exercise would be a no brainer.</div><div><br></div><div>Can Swift's parentheses-situation be sorted out before ABI stability?</div><div>Otherwise it would be a bit like if Swift had kept the special rule for the first parameter, only much worse.</div><div><br></div></div></div></div></blockquote><div><br></div></div></div><div>Out of curiosity, how do you think this would impact ABI? What are your concrete concerns here?</div><div><br></div><div>I don't think the analogy of first parameter label is relevant, as that needn't be ABI. </div><span><br><blockquote type="cite"><div><div dir="ltr"><div><div>/Jens</div><div><br></div><div><br></div><div><br></div></div></div><div class="gmail_extra"><br><div class="gmail_quote">On Fri, Jun 9, 2017 at 7:17 PM, Gor Gyolchanyan <span dir="ltr"><<a href="mailto:gor@gyolchanyan.com" target="_blank">gor@gyolchanyan.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word;line-break:after-white-space">Yes, except why would you need to define `((A, B)) -> C`?, If you need to pass a 2-element tuple into a function that takes two parameters - you can! If you want to pass two values into a function that *looks* like it takes a single 2-element tuple - you can! Seems to me that the difference between `((A, B)) -> C` and `(A, B) -> C` is virtually non-existent. But keep in mind that this only works for bare tuples (the ones that can't have labels). Non-closure functions DO have labels, which is part of their signature, so this is a different story.<div><div class="m_1761630961748148602m_1730409288391348670m_-5451479047364055047h5"><div><div><br><blockquote type="cite"><div>On Jun 9, 2017, at 6:18 PM, Gwendal Roué <<a href="mailto:gwendal.roue@gmail.com" target="_blank">gwendal.roue@gmail.com</a>> wrote:</div><br class="m_1761630961748148602m_1730409288391348670m_-5451479047364055047m_-5030093235766988749Apple-interchange-newline"><div><div style="word-wrap:break-word"><br><div><blockquote type="cite"><div>Le 9 juin 2017 à 17:12, Gor Gyolchanyan via swift-evolution <<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a>> a écrit :</div><br class="m_1761630961748148602m_1730409288391348670m_-5451479047364055047m_-5030093235766988749Apple-interchange-newline"><div><div style="word-wrap:break-word;line-break:after-white-space"><div><blockquote type="cite"><div><div><font color="#00afcd"><br></font>So I wonder if any of you have had any thoughts about what Swift's parentheses-related future (or evolutionary baggage) will be?<br><font color="#00afcd"><br></font></div></div></blockquote><br></div><div>I really wish swift used the concept of tuples **exclusively** for all purposes that involve parentheses, as well as dividing tuples into two categories:</div><div>- Bare tuples, which do not have labels.</div><div>- Rich tuples, which do.</div><div>As a consequence, here's a list of statements that would become true:</div><div>- All functions take exactly one parameter, which is a tuple.</div><div>- All closures (a.k.a. function pointers) take exactly one parameter, which is a bare tuple.</div><div>- All functions return exactly one parameter, which is a tuple.</div><div>- Pattern matching is done on a single bare tuple using a single bare tuple pattern.</div><div><br></div><div><div>The currently ongoing proposal to make a single-element tuple auto-flatten would work extremely well with this idea, by making all these changes completely backward-compatible.</div></div></div></div></blockquote><br></div><div>If I have well understood, Swift has evolved away from this.</div><div><br></div><div>If what you describe were true, added to the fact that there is no such thing as a one-element tuple in the language, then (A,B) -> C and ((A, B)) -> C could not be distinguished, for the simple reason that ((A, B)) -> C could not be defined.</div><div><br></div><div>For ((A, B)) -> C to be defined, we'd need a function that takes exactly one parameter, which is a tuple (your idea), whose single element is a tuple (oops, there is no single-valued tuples).</div><div><br></div><div>No opinion here, just they way I have understood recent Swift history.</div><div>Gwendal</div><br></div></div></blockquote></div><br></div></div></div></div></blockquote></div><br></div>
</div></blockquote></span><span><blockquote type="cite"><div><span>______________________________<wbr>_________________</span><br><span>swift-evolution mailing list</span><br><span><a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a></span><br><span><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" target="_blank">https://lists.swift.org/mailma<wbr>n/listinfo/swift-evolution</a></span><br></div></blockquote></span></div></blockquote></div><br></div>
</div></div><br>______________________________<wbr>_________________<br>
swift-evolution mailing list<br>
<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a><br>
<a href="https://lists.swift.org/mailman/listinfo/swift-evolution" rel="noreferrer" target="_blank">https://lists.swift.org/mailma<wbr>n/listinfo/swift-evolution</a><br>
<br></blockquote></div><br></div>
</div></div></blockquote></div><br></div></div>