mapping on SharedReader

[OguzYuuksel]

I have the following case with nested wrappers. I want to drop the second wrapper (Wrapper2).

Mapping in the Shared module seems quite impossible because it's writable, so we also need a function to revert the map. However, it might be possible in SharedReader. I couldn't solve my case with @dynamicMemberLookup.

enum Wrapper<S> {
    case value(S)
    case none
}

enum Wrapper2<S> {
    case value(S)
    case none
}

struct Foo {
    @SharedReader var count: Wrapper<Int>

    init(_ count: SharedReader<Wrapper<Wrapper2<Int>>>) {
        self._count = // TODO
    }
}

[mbrandonw]

Hi @OguzYuuksel, this can be solved with dynamic member look up. You want to transform a Wrapper<Wrapper2<…>> into a Wrapper<…>, which you can do via a subscript on Wrapper:

enum Wrapper<S> {
  case value(S)
  case none
}

enum Wrapper2<S> {
  case value(S)
  case none
}

extension Wrapper {
  subscript<Value>() -> Wrapper<Value> where S == Wrapper2<Value> {
    get {
      switch self {
      case .value(.value(let value)):
        .value(value)
      case .value(.none), .none:
        .none
      }
    }
    set {
      switch newValue {
      case .value(let value):
        self = .value(.value(value))
      case .none:
        self = .none
      }
    }
  }
}
import SwiftUI
func foo() {
  @State var x = Wrapper<Wrapper2<Int>>.none
  $x[] as Binding<Wrapper<Int>>
}

It's strange, of course, but I assume this is just temporary code as you try to get rid of one of the wrappers?

[OguzYuuksel]

Thank you @mbrandonw, that works! Use case is as follows:

enum OptionalFeature<Value> {
    case supported(Value)
    case unsupported
}

enum MutableProperty<Value> {
    case value(Value)
    case changing(_ previous: Value, _ next: Value)
    
    var optimisticValue: Value {
        switch self {
        case let .value(value):
            return value
        case let .changing(_, newValue):
            return newValue
        }
    }
}

// Below reducer sends set requests to the API for someFeature. During the request, the optimistic value will be presented on the UI.
// In case of failure, we can fall back to the previous value.
struct SomeFeatureReducerState {
    @Shared var someFeature: OptionalFeature<MutableProperty<Bool>>
}

// Below reducer only shows the value of someFeature. Since it does not have set logic, there's no need to keep it as a MutableProperty. We just pass the optimistic value.
struct SomeOtherFeatureReducerState {
    @SharedReader var someFeature: OptionalFeature<Bool>
}