Why state doesn't change when I use class for state instead of struct.

[abdelmajidrajad]

Hello Friends,

I come to this problem today and still not having an idea what makes things not triggered when class used instead of struct for the case when I need reference type instead of value type, I implemented Equatable for this class.

is still something missing for me ?

[RabugenTom]

Even if some fields of your class are changing, the class instance probably doesn't. If theClass is a sub state of state, setting state.theClass.text = "Hello" will not change the state which is still referencing the same instance of theClass. In other words, if you put a didSet in theClass accessor, you shouldn't see anything passing through when setting state.theClass.text = "Hello".
If you perform your change as :

let newValue = TheClass()
newValue.text = "Hello"
state.theClass = newValue

the change should be detected as you're setting a new reference to theClass in state.
A safer way to handle this is to have an immutable class with a mutable subclass (like NSAttributedString and NSMutableAttributedString). If you assign the immutable type to state, you're protecting yourself from accidentally mutating the class. You are then forced to perform your changes as

let newValue = MutatingTheClass(state.theClass)
newValue.text = "Hello"
state.theClass = newValue

You can define a computed property on state to perform these operations automatically, with some private storage for theClass

struct State {
  private var _theClass: TheClass = .init()
  public var theClass: MutableTheClass {
    get {
      MutableTheClass(self._theClass)
    }
    set {
      _theClass = newValue
    }
  }
}

This should work as you're never able to get _theClass instance out of State, but it's not exceptional performance-wise as you're instantiating a MutableTheClass each time theClass is accessed. But it remains convenient to use in a reducer and can be acceptable in some cases.

Otherwise, you can directly publicly expose theClass: TheClass, but you will need to instanciate a mutable copy when reducing if needed. I feel this will be better performance-wise though, and this would be the path I'll choose. But I would try really hard to convert my class as a value type before that. Look at ReferenceConvertible to see if you can make it work in your case.

Good luck!

[abdelmajidrajad]

Thanks for your answer, your solution is working properly for me. I am trying to keep value type but conclude that having reference type is a require:

import UIKit
@propertyWrapper
public enum Indirect<T>: Equatable where T: Equatable {
    indirect case storage(T)
    public init(wrappedValue: T) {
        self = .storage(wrappedValue)
    }
    public var wrappedValue: T {
        get {
            switch self {
            case .storage(let value):
                return value
            }
        }
        set {
            self = .storage( newValue )
        }
    }
}

struct B: Equatable {
    @Indirect var a: A?
}

struct A: Equatable {
    @Indirect var b: B?
}

I did like the solution above with a recurse reducer, but app crash on device, not on simulator (weird thing) can you explain that ?

[lukeredpath]

Value types are the natural choice for modelling your state - can I ask why you're trying to use a reference type? Is this to try and overcome some kind of performance concern by moving your state off the stack and on to the heap?

[abdelmajidrajad]

I'm absolutely agree that struct are the natural choice and we even keep using them until have case where reference type are the perfect solution.

This is what I did, start by struct until seen that reference type are a must. Please take a look into this structure, is there any other better structure that use only value types ?
`
struct B: Equatable {
var a: A?
}

struct A: Equatable {
var b: B?
}
`

[lukeredpath]

Its hard to say without knowing more about your problem domain, generally my approach to avoiding cyclic dependencies would be to introduce a parent type instead, e.g.:

struct C: Equatable {
  var a: A?
  var b: B?
}

[abdelmajidrajad]

Thanks for your answer, I want to let you know about my domain and structure so, it give more insight about why I use classes and hope find a way to use structs to keep things short and more clear.

struct Stories: Equatable {
    var storyDetail: StoryDetail?
}

struct Projects: Equatable {
    var projectDetail: ProjectDetail?
}


struct StoryDetail: Equatable {
    var projects: Projects
    var projectDetail: ProjectDetail?
}

struct ProjectDetail: Equatable {
    var stories: Stories
    var storyDetail: StoryDetail?
}

[av0c0der]

@abdelmajidrajad I think you're struggling with the same problem that I described here. Are you trying to prevent one of your parent view from mutating on their child view changes?

[abdelmajidrajad]

I read your problem, unfortunately it not mine. I have a domain where I could say reference type are a must but TCA support structs and enums.