Swift Dictionary default value

Question

A pattern I\'ve gotten used to with Python\'s defaultdicts is a dictionary that returns a default value if the value for a given key has not been explicitly set. Trying to d

Answer 1

Unless I'm misunderstanding defaultdict in Python, I don't see how nil coalescing wouldn't work for you. Let's say you had a dictionary of type [Int:Int], and you wanted it to return 0 by default. With nil coalescing it looks like this:

let dict = [1:10, 2:8, 3:64]
let valueForKey = dict[4] ?? 0

You mentioned in a comment that that wouldn't work because it wouldn't update the dictionary. I don't understand the problem, though: why would you need to update the dictionary if you knew that every instance of nil would be replaced by your default? Maybe I'm missing something here but it seems like defaults and nil coalescing are (in practice) the same.

You can change the syntax a little, if it makes things more clear:

extension Dictionary {
  subscript(key: Key, or r: Value) -> Value {
    get { return self[key] ?? r }
    set { self[key] = newValue }
  }
}

In this case, the example above could be written like this:

let dict = [1:10, 2:8, 3:64]
let valueForKey = dict[4, or: 0]

In this case, mutating methods can work on the keys, like this:

var dict = [2: 8, 3: 64, 1: 10]
dict[2, or: 0]++
dict // [2: 9, 3: 64, 1: 10]
dict[4, or: 0]++
dict // [2: 9, 3: 64, 1: 10, 4: 1]

Answer 2

Using Swift 2 you can achieve something similar to python's version with an extension of Dictionary:

// Values which can provide a default instance
protocol Initializable {
    init()
}

extension Dictionary where Value: Initializable {
    // using key as external name to make it unambiguous from the standard subscript
    subscript(key key: Key) -> Value {
        mutating get { return self[key, or: Value()] }
        set { self[key] = newValue }
    }
}

// this can also be used in Swift 1.x
extension Dictionary {
    subscript(key: Key, or def: Value) -> Value {
        mutating get {
            return self[key] ?? {
                // assign default value if self[key] is nil
                self[key] = def
                return def
            }()
        }
        set { self[key] = newValue }
    }
}

The closure after the ?? is used for classes since they don't propagate their value mutation (only "pointer mutation"; reference types).

The dictionaries have to be mutable (var) in order to use those subscripts:

// Make Int Initializable. Int() == 0
extension Int: Initializable {}

var dict = [Int: Int]()
dict[1, or: 0]++
dict[key: 2]++

// if Value is not Initializable
var dict = [Int: Double]()
dict[1, or: 0.0]

Answer 3

This changed in Swift 4, and there's now a way to read a key's value or provide a default value if the key isn't present. For example:

let person = ["name": "Taylor", "city": "Nashville"]
let name = person["name", default: "Anonymous"]

This is particularly useful when modifying dictionary values, because you can write code like this:

var favoriteTVShows = ["Red Dwarf", "Blackadder", "Fawlty Towers", "Red Dwarf"]
var favoriteCounts = [String: Int]()

for show in favoriteTVShows {
    favoriteCounts[show, default: 0] += 1
}

I covered this change and others in my article What's new in Swift 4.