Lazy init of @State objects using new Observable protocol

try this:

@MainActor
@propertyWrapper
public struct LazyState<T: Observable>: @preconcurrency DynamicProperty {
  @State private var holder: Holder

  public var wrappedValue: T {
    holder.wrappedValue
  }

  public var projectedValue: Binding<T> {
    return Binding(get: { wrappedValue }, set: { _ in })
  }

  public func update() {
    guard !holder.onAppear else { return }
    holder.setup()
  }

  public init(wrappedValue thunk: @autoclosure @escaping () -> T) {
    _holder = State(wrappedValue: Holder(wrappedValue: thunk()))
  }
}

extension LazyState {
  final class Holder {
    private var object: T!
    private let thunk: () -> T
    var onAppear = false
    var wrappedValue: T {
      object
    }

    func setup() {
      object = thunk()
      onAppear = true
    }

    init(wrappedValue thunk: @autoclosure @escaping () -> T) {
      self.thunk = thunk
    }
  }
}

// Demo
struct LinkViewUsingLazyState: View {
  @LazyState var object = TestObservationObject()
  var body: some View {
    Text("LazyState")
    Text(object.name)
    @Bindable var o = object
    TextField("hello", text: $o.name)
    Button("change") {
      object.name = "\(Int.random(in: 0 ... 1000))"
    }
  }
}

@Observable
class TestObservationObject {
  init() {
    print("init")
  }

  var name = "abc"
}

This is an extremely important initialiser for state objects that are expensive to allocate. As far as I can tell, the @State property wrapper lacks an equivalent initialiser. What is the recommended migration strategy for objects which made use of this on StateObject?

You can mark the property as an optional and initialize the value just before its needed. Keep in mind that SwiftUI creates only one instance of the state for each container instance that you declare.

That said, you can file an enhancement request

If you'd like the engineering team to consider adding a Lazy state API, please file an enhancement request using Feedback Assistant. Once you file the request, please post the FB number here.

If you're not familiar with how to file enhancement requests, take a look at Bug Reporting: How and Why?

Filed FB16804172

Yeah you can do it with an optional, that's a good idea.

But I found that you need to initialize the object in onAppear (or similar); if you try to do it in the intializer, the State isn't properly hooked up and the value gets lost. It's not really ideal, and StateObject doesn't have that limitation.

import SwiftUI

struct ContentView: View {

    @State var counter = 0

    var body: some View {
        VStack {
            HasExpensiveObject()

            // Do something to trigger this view's body to be invoked again.
            // Ideally this should NOT cause a new 'ExpensiveObject' to be initialized.

            Text("\(counter)")
            Button(action: { counter &+= 1 }, label: { Text("Refresh") })
        }
    }
}

struct HasExpensiveObject: View {

    @State var expensiveObject: ExpensiveObject?

    init() {
        // This doesn't work :(
        if expensiveObject == nil {
            expensiveObject = ExpensiveObject()
        }
    }

    var body: some View {
        
        Text(String(describing: expensiveObject))

// This does work, but it's... not pretty.

//            .onAppear {
//                if expensiveObject == nil {
//                    expensiveObject = ExpensiveObject()
//                }
//            }
    }
}

@Observable @MainActor
final class ExpensiveObject {

    init() {
        print("Doing expensive stuff in ExpensiveObject.init...")
    }

    deinit {
        print("ExpensiveObject.deinit")
    }
}

#Preview {
    ContentView()
}