In this mail I’m answering several statements made in this thread by different
people, not only Brent’s mail from which I just picked the following snippet:
> let names = people.map => person { person.name }
For me that is more difficult to read than
let names = people.map { person in person.name }
Especially when chaining is used, i.e.
let names = people.filter => person { person.isFriend }.map => person {
person.name }
(or would I have to add parentheses somewhere with this proposed syntax?)
vs.
let names = people.filter { person in person.isFriend }.map { person in
person.name }
Those „=>“ pretty much visually separate the statement in the wrong positions,
i.e. the parts grouped together visually are
1. people.filter
2. person { person.isFriend }.map
3. person { person.name }
which is simply wrong for the middle part (or parts in case of more chaining).
Whereas having the arguments in the closure separate the parts visually much
better, keeping the closures together and interspersed with the function names.
With regards to trailing closures: Having them is an important part of DSLs in
Ruby, Smalltalk and Scala.
See for example the links cited in https://news.ycombinator.com/item?id=7921011
or the Akka library (http://akka.io) or rake (Ruby’s „make" replacement).
Of course Alexander is right that the concept of a trailing closure works only
for one closure and not for several. That is indeed a thing where Smalltalk’s
syntax without any parentheses around function arguments had a really nice
advantage which is not possible in Swift (although the parameter keywords are
really great in alleviating this).
But there are so many cases (as the links above demonstrate) where a single
trailing closure is sufficient that this feature is tremendously useful.
With regards to Haskell: the above example would (typically) look like:
names = map (\person -> name person) . filter (\person -> isFriend person) $
people
which also uses only one pair of parentheses just around the lambda expressions
(because Haskell has neither parentheses around parameters nor around closures).
Visually it actually looks just the same as Swift’s closures (replacing
parentheses with braces and „->“ with „in“ and dropping the backslash which
stands in for the greek letter lambda), i.e. visually the parameters of the
closure are within the parentheses, just like in Swift.
Of course the syntactical meaning of the parentheses is different from that of
the braces but the visual effect is quite important in my eyes. That helps a
lot in readability.
With regards to „in“: I personally like it but could also live with something
like „=>“ or the bar „|“ as used in Ruby (two bars around the params) or
Smalltalk (just one bar after the params which I would prefer), e.g.
let names = people.map { person | person.name }
although the „in“ definitely looks better with syntax highlighting and when
using the wrong font like now (where the bar just looks like the upper case
letter „i“).
I think I said it already: the „in“ reminds me of the let-in-expression of
Haskell, e.g. „let foo = 3 in …“
-Thorsten_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
