Access and modify easily Array of Dictionaries in Swift

Question

I have this structure: [String: [String: Double]]()

Specifically, something like that: var dictionaries = ["GF": ["ET": 4.62, "EO": 21.0],"FD": ["EE": 80.95, "DE": 0.4]]

How can I easily access and modify nested dictionaries?

EXAMPLE UPDATED: I want to append "TT": 6 at FD and later I want to append another dictionary inside the array. At the end I'll print the results.

for (key,value) in dictionaries {

    // if array contains FD, add the record to FD
    if key.contains("FD") {
        dictionaries["FD"]!["TT"] = 6
    }
    else {
    // if array doesn't contain FD, add FD and add the record to it
        dictionaries = dictionaries+["FD"]["TT"] = 6 // <-- I know that it's wrong but I want to achieve this result in this case.
    }
}

Result of print will be:

GF -> ET - 4.62, EO - 21.0
FD -> EE - 80.95, DE - 0.4, TT - 6

MISSION: I need to append new dictionary records like in the example above, update existing ones in a simple and straightforward way, loop easily through records to read the values and print them out.

Can anyone help me? Never had the chance to manage dictionaries in Swift since now.

Answer 1

It'll be much simpler if you have the key "FD" you can use

dictionaries["FD"]!["TT"] = 6

to add a new value ["TT":6] or modify existing value of TT to 6. Note that the ! between ["FD"]!["TT"] assumes that ["FD"] exists regardless. You need to check if ["FD"] exists otherwise. Like:

if dictionaries["FD"] != nil {
    dictionaries["FD"]!["TT"] = 6
} else {
    dictionaries["FD"] = ["TT" : 6]
}

If you need to look for the key you will have to run the entire dictionary like you already tried, but dictionaries support fast enumeration for key and values like

for (key,value) in dictionaries {
    if key.contains("FD") { //or any other checks you need to identify your key
        value["TT"] = 6
    }
}

Answer 2

It is not clear what exactly you need but the exercise amused me, so I came up with this solution: we extend Dictionary so that it provides convenience methods if it is a nested dictionary.

First, because of Swift idiosyncrasies, we have to create a dummy protocol to "mark" Dictionary¹:

protocol DictionaryProtocol {
    associatedtype Key: Hashable
    associatedtype Value

    subscript(key: Key) -> Value? { get set }
    var keys: LazyMapCollection<[Key : Value], Key> { get }
}

extension Dictionary: DictionaryProtocol {}

Basically, just copy-paste² all declarations you need later from Dictionary to DictionaryProtocol.

Then, you can happily extend away. For instance, add a two-parameter subscript:

extension Dictionary where Value: DictionaryProtocol {
    typealias K1 = Key
    typealias K2 = Value.Key
    typealias V  = Value.Value

    subscript(k1: K1, k2: K2) -> V? {
        get {
            return self[k1]?[k2]
        }
        set {
            if self[k1] == nil {
                self.updateValue([K2: V]() as! Value, forKey: k1)
            }

            self[k1]![k2] = newValue
        }
    }
}

Or an alternative pretty-print³:

extension Dictionary where Value: DictionaryProtocol {
    func pretty() -> String {
        return self.keys.map { k1 in
            let row = self[k1]!.keys.map { k2 in
                return "\(k2) - \(self[k1]![k2]!)"
            }.joined(separator: ", ")

            return "\(k1) -> \(row)"
        }.joined(separator: "\n")
    }
}

You can also create a type alias for this special dictionary:

typealias D2Dictionary<K: Hashable, V> = Dictionary<K, Dictionary<K, V>>

Going back to the example in your question:

var dictionary = D2Dictionary<String, Double>()
dictionary["GF", "ET"] = 4.62
dictionary["GF", "EO"] = 21.0
dictionary["FD", "EE"] = 80.95
dictionary["FD", "DE"] = 0.4
dictionary["FD", "TT"] = 6

print(dictionary.pretty())

// > GF -> ET - 4.62, EO - 21.0
// > FD -> EE - 80.95, DE - 0.4, TT - 6.0

---

1. Background: Only protocols can be used in type bounds on extension conditions.
2. Make sure to get the types right. If we write var keys: [Key] { get }, for instance, the compiler dies with a seg fault.
3. Unfortunately, extension Dictionary: CustomStringConvertible where Value: DictionaryProtocol { ... } is not allowed, for whatever reason.