[swift-evolution] [Proposal] Set literal and Set type syntax
sethfri at gmail.com
Mon Jan 18 15:47:33 CST 2016
I dig the idea of Sets having a literal syntax, rather than continuing to
be the ugly stepchild of CollectionTypes. I'm not sure, though, that this
particular literal syntax is very obvious. While the Array and Dictionary
syntaxes are similar enough to many other languages in which arrays and
maps exist, I might be confused if I saw your proposed syntax in Swift.
Not to mention that it's not the prettiest syntax, but that's more
On Mon, Jan 18, 2016 at 1:24 PM, Michael Henson via swift-evolution <
swift-evolution at swift.org> wrote:
> Swift currently has literal and type shorthand syntax for native Array and
> Dictionary types, but not the Set type. It would be useful to have a
> literal shorthand for Set as well.
> The existing productions for array and dictionary literals and types share
> brackets as delimiters, differing only in the contents between the
> brackets. That poses a slight problem for Set because any syntax, to be
> useful, must also be easily distinguishable from the other types.
> Consider that Arrays and Dictionaries are both naturally indexed
> collections. Arrays by the integer value of the order of items in the
> collection, usually implicitly, and Dictionaries by the hashed key
> associated with each value.
> Arrays, implicit index:
> let array = ["a", "b", "c"]
> var array: [String]
> var empty: [String] = 
> Dictionaries, explicit index:
> let dictionary = ["a": 1, "b": 5, "c": 9]
> var dictionary: [String: Int]
> var empty: [String: Int] = [:]
> Sets, by contrast, have no particular order and no "key". Even though the
> Set is enumerable and iterable, it isn't indexed. With that in mind, we can
> declare that a Set literal or Set type literal should distinguish itself by
> declaring that it has no index.
> The Set literal could be:
> let set = [ _: "a", "b", "c" ]
> var set = [ _: String ]
> var empty: [ _: String ] = [_:]
> In the grammar:
> set-literal -> [ _ : array-literal-items[opt] ]
> literal-expression -> array-literal | dictionary-literal | set-literal
> set-type -> [ _ : type ]
> type -> array-type | dictionary-type | set-type | ... etc.
> let x = [ _: "A", "B", "C" ]
> let y: [ _: String ] = [ _: ]
> Alternatives considered:
> Without literals, declaring a Set type is straightforward, easy to
> recognize, and not much more verbose. There might not be enough of a
> difference to justify special syntax in the core language.
> swift-evolution mailing list
> swift-evolution at swift.org
*Software Development Engineer II*
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the swift-evolution