How to assign a reference to a Dictionary in Swift - swift

Question

I am working with a complex dictionary and want to make it easy to work just assigning a variable to it.
myDictionay["with"]["complex"]["sub"]["dictionary"] = "NewValue"
I just want this:
let smaller = myDictionay["with"]["complex"]["sub"]
smaller["dictionary"] = "NewValue"
How can I do it?

Answer 1

The Swift Dictionary (and Array / Set) follows pass by reference semantics, rather than pass by value semantics (if you look in the headers you'll see it is a struct, not a class). This means that when you assign a Dictionary instance from one variable to another variable, and change the value associated with the new variable, it does not in fact change the value associated with the original value. As such, the syntax you are looking for is not possible with a Swift Dictionary. Having said that, you can always use an NSMutableDictionary instead, and then the syntax you are hoping for will work.

Answer 2

You could use a closure to perform the inner access for you:
let smaller : (inout _: [String : [String : [String :[String : String]]]], key: String, val: String) -> () = { dict, key, val in
dict["with"]?["complex"]?["sub"]?[key] = val
return ()
}
/* setup example */
var a = [String : String]()
var b = [String :[String : String]]()
var c = [String : [String : [String : String]]]()
var myDictionary = [String : [String : [String :[String : String]]]]()
a["dictionary"] = "OldValue"
b["sub"] = a
b["anothersub"] = a
c["complex"] = b
myDictionary["with"] = c
/* example */
print(myDictionary)
/* ["with": ["complex": ["anothersub": ["dictionary": "OldValue"],
"sub": ["dictionary": "OldValue"]]]] */
smaller(&myDictionary, key: "dictionary", val: "NewValue")
print(myDictionary)
/* ["with": ["complex": ["anothersub": ["dictionary": "OldValue"],
"sub": ["dictionary": "NewValue"]]]] */
Or, more condensed: you can use a closure specifically with a dictionary name accessible in the scope where closure is used (i.e., no need to send a reference to the dictionary as an argument to the closure).
let smaller2 : (String, String) -> () = { myDictionary["with"]?["complex"]?["sub"]?[$0] = $1 }
smaller2("dictionary", "NewerValue")
print(myDictionary)
/* ["with": ["complex": ["anothersub": ["dictionary": "OldValue"],
"sub": ["dictionary": "NewerValue"]]]] */
If you're handling your dictionary myDictionary as some class property, you could, as an alternative to the above, define a class method that returns closures as the ones above, given a "dictionary key path", e.g. "with.complex.sub", as argument:
/* say 'myDictionary' is some class property (initialized as in example above)
In same class, introduce the following method */
func dictClosure(dictKeyPath: String) -> ((String, String) -> ()) {
let arr = dictKeyPath.componentsSeparatedByString(".")
if arr.count == 3 {
return {
myDictionary[arr[0]]?[arr[1]]?[arr[2]]?[$0] = $1 }
}
else {
return {
_, _ in
print("This closure is invalid")
}
}
}
/* example usage */
var smaller3 = dictClosure("with.complex.sub")
smaller3("dictionary", "NewestValue")
smaller3 = dictClosure("with.complex.anothersub")
smaller3("dictionary", "AlsoNewValue")
print(myDictionary)
/* ["with": ["complex": ["anothersub": ["dictionary": "AlsoNewValue"],
"sub": ["dictionary": "NewestValue"]]]] */
The above assumes dictionary key paths of three levels ("one.two.three"), and yields a closure for accessing the dictionary on the fourth level.
Finally note that for all solutions above, calling the smaller closures will allow for adding new key-value pairs into the fourth level of the dictionary, not only mutating the value of existing pairs. E.g. the key typo smaller3("dcitionary", "NewValue") will add a key-value pair "dcitionary": "NewValue" into the fourth level dictionary. If you only want to allow mutating values for existing key, simply add ? after the inner-most key access in the smaller closures above:
/* smaller ... */
dict["with"]?["complex"]?["sub"]?[key]? = val
/* smaller2 ... */
myDictionary["with"]?["complex"]?["sub"]?[$0]? = $1
/* smaller3 ... */
myDictionary[arr[0]]?[arr[1]]?[arr[2]]?[$0]? = $1