Lazy resolver

LazyResolver.swift

          class TestResolver {
    var identifier: String

    @ResolveKeypathLazily(keyPath: \TestResolver.identifier)
    var hamster: Int = 1

    init(identifier: String) {
        self.identifier = identifier
    }
}

@propertyWrapper
struct ResolveKeypathLazily<Value: Equatable, T> {
    private var stored: Value
    private let aKeyPath: KeyPath<T, String>
    private var resolved: String?

    public init(wrappedValue: Value, keyPath: KeyPath<T, String>) {
        self.stored = wrappedValue
        self.aKeyPath = keyPath
    }

    var wrappedValue: Value {
        get { fatalError() }
        set { fatalError() }
    }

    public static subscript(
        _enclosingInstance observed: T,
        wrapped wrappedKeyPath: ReferenceWritableKeyPath<T, Value>,
        storage storageKeyPath: ReferenceWritableKeyPath<T, Self>
      ) -> Value {
      get {
        // Resolve the keypath
        if observed[keyPath: storageKeyPath].resolved == nil {
            let keyPath = observed[keyPath: storageKeyPath].aKeyPath
            observed[keyPath: storageKeyPath].resolved = observed[keyPath: keyPath]
        }

        return observed[keyPath: storageKeyPath].stored
      }
      set {
        observed[keyPath: storageKeyPath].stored = newValue
      }
    }
}