[swift-evolution] [Proposal] Set literal and Set type syntax

[Will Entriken]

Another interpretation is that a Set *is* indexed, and its value is
nonexistent. Or, in other words:

var x = [String: ()]
var y = [String: ()]()

Literals might be

var z = ["bourbon": (), "scotch": (), "beer": ()]

or more succinctly

var a = ["bourbon": (), "scotch", "beer"]

Other choices like Void or nil may be more appropriate.


On Mon, Jan 18, 2016 at 4: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.
>
>
> Examples:
>
> 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.
>
> Mike
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20160118/4bc11465/attachment.html>