A lightweight collection of key-value pairs.

    @frozen struct KeyValuePairs<Key, Value>

    Use a KeyValuePairs instance when you need an ordered collection of key-value pairs and don’t require the fast key lookup that the Dictionary type provides. Unlike key-value pairs in a true dictionary, neither the key nor the value of a KeyValuePairs instance must conform to the Hashable protocol.

    You initialize a KeyValuePairs instance using a Swift dictionary literal. Besides maintaining the order of the original dictionary literal, KeyValuePairs also allows duplicates keys. For example:

    let recordTimes: KeyValuePairs = ["Florence Griffith-Joyner": 10.49,
                                          "Evelyn Ashford": 10.76,
                                          "Evelyn Ashford": 10.79,
                                          "Marlies Gohr": 10.81]
    // Prints "(key: "Florence Griffith-Joyner", value: 10.49)"

    Some operations that are efficient on a dictionary are slower when using KeyValuePairs. In particular, to find the value matching a key, you must search through every element of the collection. The call to firstIndex(where:) in the following example must traverse the whole collection to find the element that matches the predicate:

    let runner = "Marlies Gohr"
    if let index = recordTimes.firstIndex(where: { $0.0 == runner }) {
        let time = recordTimes[index].1
        print("\(runner) set a 100m record of \(time) seconds.")
    } else {
        print("\(runner) couldn't be found in the records.")
    // Prints "Marlies Gohr set a 100m record of 10.81 seconds."

    Key-Value Pairs as a Function Parameter

    When calling a function with a KeyValuePairs parameter, you can pass a Swift dictionary literal without causing a Dictionary to be created. This capability can be especially important when the order of elements in the literal is significant.

    For example, you could create an IntPairs structure that holds a list of two-integer tuples and use an initializer that accepts a KeyValuePairs instance.

    struct IntPairs {
        var elements: [(Int, Int)]
        init(_ elements: KeyValuePairs<Int, Int>) {
            self.elements = Array(elements)

    When you’re ready to create a new IntPairs instance, use a dictionary literal as the parameter to the IntPairs initializer. The KeyValuePairs instance preserves the order of the elements as passed.

    let pairs = IntPairs([1: 2, 1: 1, 3: 4, 2: 1])
    // Prints "[(1, 2), (1, 1), (3, 4), (2, 1)]"

    Citizens in Swift




    Citizens in Swift

    where Key:Sendable, Value:Sendable


    • protocol Sendable

      A type whose values can safely be passed across concurrency domains by copying.

    Extension in SwiftSyntaxBuilder

    where Key:ExpressibleByLiteralSyntax, Value:ExpressibleByLiteralSyntax