8

I am constructing an array of booleans to store the state of the sections in a UICollectionView. It is a variable stored as a property of my UIViewController:

var _weekSelections : Array<Bool>!

Then, in a function called by loadView(), I construct the array and assign a value to the first index:

_weekSelections = Array<Bool>(count:_weekCount, repeatedValue:false)
_weekSelections[0] = true

The value at index 0 remains false! The array is constructed, and has multiple elements, but any assignment that I make to an index does not affect the value stored at that index, even if I check the value on the very next line of code. I know that Swift makes a copy of an array if I perform an action that may change its length, but I don't think this is a case where a copy would me made. The only way I can get any value to change is if I manually create a copy as follows:

var copy = _weekSelections
copy[0] = true
_weekSelections = copy

Am I missing something obvious or could this be a strange bug?

Improve this question
7
  • 1
    Interesting. I can reproduce this, but if I move the code to an init() call from loadView(), it works. Still trying to figure out what's going on. Commented Jun 25, 2014 at 19:27
  • It happens with all types of arrays, at least when globally stored and in loadView() or a descendant. I couldn't find anything in the documentation specifying different modification behavior for globally vs locally stored arrays, and if what you say is true then it must be something different. Commented Jun 25, 2014 at 19:48
  • 1
    Here's something odd: I can make a minimal Swift class in a playground where your code works fine. And then if I say it inherits from NSObject, I can reproduce your problem with it. That's the only change. I've got a reproduction down to about 12 lines of code... Repro: pastebin.com/2Xc1qrHQ Commented Jun 25, 2014 at 19:53
  • Incidentally: What do you mean by "globally stored", exactly? Outside the class completely, at global scope? (I can reproduce this with a stored property of the class...) Commented Jun 25, 2014 at 19:58
  • Sorry, my terminology wasn't clear. I do mean a stored variable that is a property of the class. Changing it in the question. Commented Jun 25, 2014 at 20:38

2 Answers 2

Reset to default
2

For the sake of having my code on SO rather than Pastebin, here's my observation. This looks like some kind of bug or unexpected behaviour when using an optional array in a Swift class derived from an Objective C class. If you use a plain Swift class, this works as expected:

class Foo {
    var weekSelections: Array<Bool>!
    func test() {
        weekSelections = Array<Bool>(count: 10, repeatedValue: false)
        weekSelections[0] = true;
        println(weekSelections[0]) // Prints "true"
    }
}

var foo = Foo()
foo.test()

However, if you derive Foo from NSObject:

import Foundation

class Foo : NSObject { // This derivation is the only difference from the code above
    var weekSelections: Array<Bool>!
    func test() {
        weekSelections = Array<Bool>(count: 10, repeatedValue: false)
        weekSelections[0] = true;
        println(weekSelections[0]) // Prints "false"
    }
}

var foo = Foo()
foo.test()

Even in this case, if you do your weekSelections initialisation in an initialiser, then it works:

class Foo : NSObject {
    var weekSelections: Array<Bool>!
    init() {
        weekSelections = Array<Bool>(count: 10, repeatedValue: false)
        weekSelections[0] = true;
        println(weekSelections[0]) // Prints "true"
    }
}

var foo = Foo()

Personally, I'd say that this is a bug. I can't see anything in any documentation that would explain the difference in behaviour when derived from NSObject.

I also can't see anything that says that optional array properties would be immutable. This would be especially strange when you consider that "immutable" arrays are actually mutable in Swift, i.e. this:

// Use "let" to declare an "immutable" array
let weekSelections = Array<Bool>(count: 10, repeatedValue: false)
weekSelections[0] = true;
println(weekSelections[0]); // Prints "true"; arrays are never really "immutable" in Swift

...works fine, and is currently documented as being valid, even if it seems a bit odd.

Personally, I'd use whatever workaround you can and raise a bug with Apple, to see what light they can shed.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

Not an explanation, but a workaround. The issue isn't with the count:repeatedValue initializer, but rather with the array being assigned to an optional variable. From what I can tell optional arrays can only use accessor methods and not mutator methods--effectively they're immutable. Temporarily assigning _weekSelections to a non-optional variable before attempting to change its contents (and assigning back to _weekSelections when done) will work. Please note that this seems to create a new array (with the same elements) on assignments, so there may be memory issues to consider if the array is very big. Of course, simply using a non-optional variable in the first place will also work.

As for why optional arrays aren't mutable, that may be a bug or there may be some esoteric reason for it I'm not fathoming. Anyone else have a plausible-sounding theory?

Improve this answer

10 Comments

It is informative that this is a problem with optional variables, but the workaround you described is the one I already included in the question. As for using a non-optional variable, I could do that but then I would be forced to initialize it either statically or during the object initialization, and I don't know how large it's going to be until I calculate _weekCount with loaded data. I'm preferring to wait and use the count:repeatedValue: initializer.
@EricGratta: Than edit the subject of the question to indicate that you understand that the issue isn't with the initializer. You're definitely giving that impression.
I didn't know that it wasn't a problem until just now!
@EricGratta: You can just initialize it with an empty array and reassign later.
@EricGratta: Better subject. The workaround still works for you. see comment above.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.