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 ] = [ _: ]
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.