Swift Dictionaries
No less than important data structure that contains unique keys with corresponding values.
Retrieving a value by its key takes constant time, whereas searching an array for a particular element grows linearly to arrays size. Dictionaries are not ordered, key-value pairs are not enumerated, meaning for in
is undefined.
enum Setting {
case text(String)
case int(Int)
case bool(Bool)
}
let defaultSettings: [String: Setting] = [
"darkMode": .bool(false),
"Name": .text("Mark"),
]
defaultSettings["Name"]
To get the optional of underlying value subscription []
is used.
Mutating Dictionaries
Just like arrays, dictionaries defined using let
are immutable.
To remove a value from a mutable dictionary, it may either be set to nil
or call removeValue(forKey:)
.
defaultSettings["Name"]
var userSettings = defaultSettings
userSettings["Name"] = .text("Dave")
userSettings["active-mode"] = .bool(true)
Here, value of defaultSettings
didn't change.
Update is done with updateValue(_:forKey:)
method:
let oldName = userSettings.updateValue(.text("Tim"), forKey: "Name")
userSettings["Name"]
oldName
Useful methods
Merge
To combine default settings dictionary with any custom settings overriding defaults yet still including default values for any keys that aren't customized is called: merging
Dictionary has a merge(_:uniquingKeysWith:)
method, which takes the key-value pairs to be merged in and a function that specifies how to combine two values with the same key.
var settings = defaultSettings
let overriddenSettings: [String:Setting] = ["Name": .text("Timothy")]
settings.merge(overriddenSettings, uniquingKeysWith: { $1})
settings
{ $1 }
is used as the policy for combining two values: If a key exists in both settings
and overriddenSettings
, value from the latter is used.
A new dictionary can be constructed out of a sequence of (Key, Value) pairs. If we can guarantee that the keys are unique, Dictionary(uniqueKeysWithValues:)
may be utilized. However, if key may exist multiple times, a function to combine the two values with same key must be provided. For example, computation of rate of appearance in a sequence may be done with a map
over each element, combining it with a 1, then, creating a dictionary out of the resulting element-frequency pairs. If two values for the same key are met, the frequencies are simply added up using +
operator.
extension Sequence where Element: Hashable {
var frequencies: [Element:Int] {
let frequencyPairs = self.map{ ($0, 1) }
return Dictionary(frequencyPairs, uniquingKeysWith: +)
}
}
let frequencies = "hello".frequencies // ["e": 1, "h": 1, "o": 1, "l": 2]
let filtered = frequencies.filter{ $0.value > 1 }
filtered // ["l": 2]
Map over dictionary values
Because Dictionary
is a subclass of Sequence
, it already has a map
method that produces an array. However, to keep the dictionary structure intact and only transform its values mapValues
is utilized.
let settingsAsStrings = settings.mapValues {
setting -> String in
switch setting {
case .text(let text): return text
case .int(let number): return String(number)
case .bool(let value): return String(value)
}
} // ["darkMode": "false", "Name": "Timothy"]
Hashable requirement detail
Dictionaries are hash tables, where each key is assigned with position in memory based on the key's hashValue
. Dictionary
therefore requires it's Key
type to conform to the Hashable
protocol. All the basic data types of standard library (strings, integers, booleans) already do. Moreover, if array's elements are hashable, the array itself conforms as well.
In order to maintain the performance, has table require the types stored in them to provide a fast and far-fetching hash deriving function. The compiler generates Hashable
conformance by use of standard library's hash function that custom types can hook into.
For structs and enumerations, compiler will synthesize Hashable
conformance for as long as elements are Hashable
.
If for some reason a custom type has 1 or more stored properties that must be ignored for hashing, Equatable
conformance must be met first, then, hash(into:)
requirement of the Hashable
protocol. This method receives a Hasher
, which wraps a universal hash function and captures the state of the hash function on the go. The hasher has a combine
method that accepts any hashable value. Hence, all the components, except of transient (lazy) ones, of a custom type must be fed to the hasher with combine
.
Equality checking must also be performed on these essential components excluding transience, because there is an invariant to be held:
"Two instances that are equal (as defined by == implementation) must have the same hash value", while reverse is incorrect:
"Two instances with the same hash value don't necessarily compare equally". This makes sense, since there's only so much of hash values, while infinite number of strings.
Swift Sets
Set
is an unordered collection of elements, with each element appearing only once. Think of set as a dictionary that only stores keys and no values. Like Dictionary
, Set
is implemented with a hash table and is as performant and demanding.
Test for a membership operation has a constant cost while arrays has a linear cost.
Set
conforms to the ExpressibleByArrayLiteral
protocol, which means it can be initialized with a literal
let naturals: Set = [1,2,3,2]
naturals // {2, 3, 1}
naturals.contains(0) // false
Note that '2' appears only once in the set, duplicate never gets inserted.
Set is closely related to mathematical concept of a set; common operations like subtraction are supported
Top comments (0)