swift: modifying arrays inside dictionaries

Question

How can I easily add elements to an array inside a dictionary? It's always complaining with could not find member 'append' or could not find an overload for '+='

var dict = Dictionary<String, Array<Int>>()
dict["key"] = [1, 2, 3]

// all of these fail
dict["key"] += 4
dict["key"].append(4) // xcode suggests dict["key"].?.append(4) which also fails
dict["key"]!.append(4)
dict["key"]?.append(4)

// however, I can do this:
var arr = dict["key"]!
arr.append(4) // this alone doesn't affect dict because it's a value type (and was copied)
dict["key"] = arr

if I just assign the array to a var, modify it and then reassign it to the dict, won't I be copying everything? that wouldn't be efficient nor elegant.

Solution 1

Swift beta 5 has added this functionality, and you've nailed the new method in a couple of your attempts. The unwrapping operators ! and ? now pass through the value to either operators or method calls. That is to say, you can add to that array in any of these ways:

dict["key"]! += [4]
dict["key"]!.append(4)
dict["key"]?.append(4)

As always, be careful about which operator you use -- force unwrapping a value that isn't in your dictionary will give you a runtime error:

dict["no-key"]! += [5]        // CRASH!

Whereas using optional chaining will fail silently:

dict["no-key"]?.append(5)     // Did it work? Swift won't tell you...

Ideally you'd be able to use the new null coalescing operator ?? to address this second case, but right now that's not working.

---

Answer from pre-Swift beta 5:

It's a quirk of Swift that it's not possible to do what you're trying to do. The issue is that the value of any Optional variable is in fact a constant -- even when forcibly unwrapping. If we just define an Optional array, here's what we can and can't do:

var arr: Array<Int>? = [1, 2, 3]
arr[0] = 5
// doesn't work: you can't subscript an optional variable
arr![0] = 5
// doesn't work: constant arrays don't allow changing contents
arr += 4
// doesn't work: you can't append to an optional variable
arr! += 4
arr!.append(4)
// these don't work: constant arrays can't have their length changed

The reason you're having trouble with the dictionary is that subscripting a dictionary returns an Optional value, since there's no guarantee that the dictionary will have that key. Therefore, an array in a dictionary has the same behavior as the Optional array, above:

var dict = Dictionary<String, Array<Int>>()
dict["key"] = [1, 2, 3]
dict["key"][0] = 5         // doesn't work
dict["key"]![0] = 5        // doesn't work
dict["key"] += 4           // uh uh
dict["key"]! += 4          // still no
dict["key"]!.append(4)     // nope

If you need to change something in an array in the dictionary you'll need to get a copy of the array, change it, and reassign, like this:

if var arr = dict["key"] {
    arr.append(4)
    dict["key"] = arr
}

ETA: Same technique works in Swift beta 3, though constant arrays no longer allow changes to contents.

Solution 2

The accepted answer bypasses the following much simpler possibility, which also works for older Swift versions:

var dict = Dictionary<String, Array<Int>>()
dict["key"] = [1, 2, 3]

print(dict)

dict["key", default: [Int]()].append(4)

print(dict)

This will print:

["key": [1, 2, 3]]
["key": [1, 2, 3, 4]]

And this:

var dict = Dictionary<String, Array<Int>>()
dict["key", default: [Int]()].append(4)
print(dict)

will print:

["key": [4]]

Solution 3

As a simple workaround you can use a NSMutableArray:

import Foundation

var dict = Dictionary<String, NSMutableArray>()
dict["key"] = [1, 2, 3] as NSMutableArray
dict["key"]!.addObject(4)

I am using effectively such simple solution in my project:

https://github.com/gui-dos/Guigna/blob/5c02f7e70c8ee3b2265f6916c6cbbe5cd3963fb5/Guigna-Swift/Guigna/GuignaAppDelegate.swift#L1150-L1157

Solution 4

Here is what I was telling Nate Cook, in the comments for his quality answer. This is what I consider "easily [adding] elements to an array inside a dictionary":

dict["key"] = dict["key"]! + 4
dict["key"] = dict["key"] ? dict["key"]! + 4 : [4]

For now, we need to define the + operator ourselves.

@infix func +<T>(array: T[], element: T) -> T[] {
    var copy = array
    copy += element
    return copy
}

I think this version removes too much safety; maybe define it with a compound operator?

@infix func +<T>(array: T[]?, element: T) -> T[] {
    return array ? array! + element : [element]
}

dict["key"] = dict["key"] + 4

Finally, this is the cleanest I can get it, but I'm confused about how array values/references work in this example.

@assignment func +=<T>(inout array: T[]?, element: T) {
    array = array + element
}

dict["key"] += 5

View more solutions

Comments

[Nate Cook]

No - subscripting a dictionary gives you back an Optional, so it's like you're working with the optional array in my first example.

[Jessy]

I don't know why Apple didn't define the + operator for arrays. If you do it yourself, you can use dict["key"] = dict["key"]! + 4.

[Nate Cook]

The += operator is defined, but only for mutable arrays. dict["key"]! is immutable (it can't have its length changed). When you use dict["key"] = dict["key"]! + 4 you're creating a brand new array and reassigning it to dict["key"] -- different than .append(4) or += 4.

[Jessy]

I didn't say +=, I said +. Obviously you're going to be creating a new array when you "add to" an immutable array (e.g. your var arr = dict["key"]); Apple should be handling the logic in + and then copying it over to +=.

[Nate Cook]

Sorry, what are you hoping to do that Apple didn't implement?

[maltalef]

It's not without great sadness that I'm about to give you the green tick. Really, Apple? I hope if they don't redesign this bit of the language, they at least make a new language construct especially for this case. Anyway: I just tried the dict["key"] = dict["key"]!.append(4) bit in playground and I'm still getting the could not find member 'append' error. What gives?

[Nate Cook]

Yeah, that was me being too clever. The crucial part of all this is that you need a variable copy of the array before you can make any changes to it and then assign it back to dict["key"]. That last bit doesn't actually make a copy, just forcibly unwraps it, so the array is still immutable and doesn't have the append method.

[Nate Cook]

That's right, since NSMutableArray is a class, unlike Swift's native arrays, which are defined as structs. In this implementation dict["key"]! is still immutable, but that doesn't matter because you can change an immutable class's underlying properties.

[maltalef]

For what it's worth, it's an amazing workaround. Well, for someone like me who's still far from getting the nitty-gritty of swift, at least. I'd still be a little concerned about it copying stuff in the background and me forgetting it and using this in a tight loop where performance is very important...

[maltalef]

It does work and is a very simple and sensible workaround. I had already started to dream of NS*-less code, though :(

[Martin R]

Congratulations! First gold badge holder for Swift!

[Denis Bystruev]

Great answer which could be further simplified with dict["key", default: []].append(4)