@@ -309,7 +309,7 @@ public struct Mirror {
309309 /// `subject` is not a class instance. The default is `.generated`.
310310 public init < Subject> (
311311 _ subject: Subject ,
312- children: DictionaryLiteral < String , Any > ,
312+ children: KeyValuePairs < String , Any > ,
313313 displayStyle: DisplayStyle ? = nil ,
314314 ancestorRepresentation: AncestorRepresentation = . generated
315315 ) {
@@ -464,25 +464,25 @@ extension Mirror {
464464
465465/// A lightweight collection of key-value pairs.
466466///
467- /// Use a `DictionaryLiteral ` instance when you need an ordered collection of
467+ /// Use a `KeyValuePairs ` instance when you need an ordered collection of
468468/// key-value pairs and don't require the fast key lookup that the
469469/// `Dictionary` type provides. Unlike key-value pairs in a true dictionary,
470- /// neither the key nor the value of a `DictionaryLiteral ` instance must
470+ /// neither the key nor the value of a `KeyValuePairs ` instance must
471471/// conform to the `Hashable` protocol.
472472///
473- /// You initialize a `DictionaryLiteral ` instance using a Swift dictionary
473+ /// You initialize a `KeyValuePairs ` instance using a Swift dictionary
474474/// literal. Besides maintaining the order of the original dictionary literal,
475- /// `DictionaryLiteral ` also allows duplicates keys. For example:
475+ /// `KeyValuePairs ` also allows duplicates keys. For example:
476476///
477- /// let recordTimes: DictionaryLiteral = ["Florence Griffith-Joyner": 10.49,
477+ /// let recordTimes: KeyValuePairs = ["Florence Griffith-Joyner": 10.49,
478478/// "Evelyn Ashford": 10.76,
479479/// "Evelyn Ashford": 10.79,
480480/// "Marlies Gohr": 10.81]
481481/// print(recordTimes.first!)
482482/// // Prints "("Florence Griffith-Joyner", 10.49)"
483483///
484484/// Some operations that are efficient on a dictionary are slower when using
485- /// `DictionaryLiteral `. In particular, to find the value matching a key, you
485+ /// `KeyValuePairs `. In particular, to find the value matching a key, you
486486/// must search through every element of the collection. The call to
487487/// `firstIndex(where:)` in the following example must traverse the whole
488488/// collection to find the element that matches the predicate:
@@ -499,67 +499,70 @@ extension Mirror {
499499/// Dictionary Literals as Function Parameters
500500/// ------------------------------------------
501501///
502- /// When calling a function with a `DictionaryLiteral ` parameter, you can pass
502+ /// When calling a function with a `KeyValuePairs ` parameter, you can pass
503503/// a Swift dictionary literal without causing a `Dictionary` to be created.
504504/// This capability can be especially important when the order of elements in
505505/// the literal is significant.
506506///
507507/// For example, you could create an `IntPairs` structure that holds a list of
508508/// two-integer tuples and use an initializer that accepts a
509- /// `DictionaryLiteral ` instance.
509+ /// `KeyValuePairs ` instance.
510510///
511511/// struct IntPairs {
512512/// var elements: [(Int, Int)]
513513///
514- /// init(_ elements: DictionaryLiteral <Int, Int>) {
514+ /// init(_ elements: KeyValuePairs <Int, Int>) {
515515/// self.elements = Array(elements)
516516/// }
517517/// }
518518///
519519/// When you're ready to create a new `IntPairs` instance, use a dictionary
520520/// literal as the parameter to the `IntPairs` initializer. The
521- /// `DictionaryLiteral ` instance preserves the order of the elements as
521+ /// `KeyValuePairs ` instance preserves the order of the elements as
522522/// passed.
523523///
524524/// let pairs = IntPairs([1: 2, 1: 1, 3: 4, 2: 1])
525525/// print(pairs.elements)
526526/// // Prints "[(1, 2), (1, 1), (3, 4), (2, 1)]"
527527@_fixed_layout // FIXME(sil-serialize-all)
528- public struct DictionaryLiteral < Key, Value> : ExpressibleByDictionaryLiteral {
529- /// Creates a new `DictionaryLiteral ` instance from the given dictionary
528+ public struct KeyValuePairs < Key, Value> : ExpressibleByDictionaryLiteral {
529+ /// Creates a new `KeyValuePairs ` instance from the given dictionary
530530 /// literal.
531531 ///
532532 /// The order of the key-value pairs is kept intact in the resulting
533- /// `DictionaryLiteral ` instance.
533+ /// `KeyValuePairs ` instance.
534534 public init ( dictionaryLiteral elements: ( Key , Value ) ... ) {
535535 self . _elements = elements
536536 }
537537 @usableFromInline // FIXME(sil-serialize-all)
538538 internal let _elements : [ ( Key , Value ) ]
539539}
540540
541- /// `Collection` conformance that allows `DictionaryLiteral` to
541+ @available ( swift, deprecated: 5.0 , renamed: " KeyValuePairs " )
542+ public typealias DictionaryLiteral < Key, Value> = KeyValuePairs < Key , Value >
543+
544+ /// `Collection` conformance that allows `KeyValuePairs` to
542545/// interoperate with the rest of the standard library.
543- extension DictionaryLiteral : RandomAccessCollection {
546+ extension KeyValuePairs : RandomAccessCollection {
544547 public typealias Indices = Range < Int >
545548
546549 /// The position of the first element in a nonempty collection.
547550 ///
548- /// If the `DictionaryLiteral ` instance is empty, `startIndex` is equal to
551+ /// If the `KeyValuePairs ` instance is empty, `startIndex` is equal to
549552 /// `endIndex`.
550553 @inlinable // FIXME(sil-serialize-all)
551554 public var startIndex : Int { return 0 }
552555
553556 /// The collection's "past the end" position---that is, the position one
554557 /// greater than the last valid subscript argument.
555558 ///
556- /// If the `DictionaryLiteral ` instance is empty, `endIndex` is equal to
559+ /// If the `KeyValuePairs ` instance is empty, `endIndex` is equal to
557560 /// `startIndex`.
558561 @inlinable // FIXME(sil-serialize-all)
559562 public var endIndex : Int { return _elements. endIndex }
560563
561564 // FIXME(ABI)#174 (Type checker): a typealias is needed to prevent <rdar://20248032>
562- /// The element type of a `DictionaryLiteral `: a tuple containing an
565+ /// The element type of a `KeyValuePairs `: a tuple containing an
563566 /// individual key-value pair.
564567 public typealias Element = ( key: Key , value: Value )
565568
0 commit comments