setter with array questions.

The answer to your question is : NO.

In Swift, Array is a value type, so any modifications to a single element (append, remove, replace,...) would invoke setter, when you made the property as computed, as well as the entire array replacement.

To achieve your goal, using KVO is the best way I think, but it's not the power of swift, but the power of Objective-C runtime.

Addition: if you can easily write the method, it may be easier than using KVO.

i went with a method.

It's a darned shame, I would really like to be able to use code that looks like this:

myArray += newObject

rather than code that looks like this:

myArraysParentObject.addChildToSpecificArray(newObject)

and still have the option of tweaking internals in the parent object to align with the contents of the array.

KVO is awesome. It's a little draining to support, bc the design pattern is a bit non-swift. since i'm at a prototyping stage... probably not the best choice. meanwhile... had an oddity: built a getter ONLY property, and tried to invoke it from another object. the compiler flagged the call, saying the property did not exist. I may stay away from getters/setters for a bit.

thanks btw. exactly what I needed to know.

There are some ways you could use a += syntax, if any of them fit your design and preferences.

If the reference to the parent class is internal and can safely be a var, you can define += to take the Parent and array element type as parameters. You wouldn't be able to modify a Parent instance declared with let, though.

class Parent
{
    var array01: Array<Int> = []
    var array02: Array<String?> = []

    /* ... */
}

func += (inout left: Parent, right: Int)
{
    left.array01.append(right)
    left.array02.append("\(right)")
}

func -= (inout left: Parent, right: Int)
{
    if let index = left.array01.indexOf(right)
    {
        left.array01.removeAtIndex(index)
        left.array02.removeAtIndex(index)
    }
}

You could wrap the info into a struct instead of storing it in different arrays, and override += to take that specific array type and the primary element type as arguments.

struct Thing
{
    var id: Int
    var name: String?
}

func += (inout left: Array<Thing>, right: Int)
{
    left.append(Thing(id: right, name: "\(right)"))
}

func -= (inout left: Array<Thing>, right: Int)
{
    var index: Int = 0
    let count = left.count
    for (index = 0; index < count; ++index){if left[index].id == right {break}}
    if index < count {left.removeAtIndex(index)}
}


class Parent
{
    var array: Array<Thing> = []

    /* ... */
}

This third way is similar to the first, but the Parent class instance can be declared using let for a constant pointer since it's no longer the direct target of += and -=. But when you access the arrays, you will need to prefix them with the struct property name too.

struct Thing
{
    var array01: Array<Int> = []
    var array02: Array<String?> = []
}

class Parent
{
    var stored: Thing = Thing()
   
    /* ... */
}


func += (inout left: Thing, right: Int)
{
    left.array01.append(right)
    left.array02.append("\(right)")
}

func -= (inout left: Thing, right: Int)
{
    if let index = left.array01.indexOf(right)
    {
        left.array01.removeAtIndex(index)
        left.array02.removeAtIndex(index)
    }
}