PartialCasePath and AnyCasePath?

[maximkrouk]

I'm using a type, called CasePathValueDetector which can detect if the case is an expected case, but it erases the Value type from CasePath to enable me to use arrays of CasePath for cases with different associated values

public struct CasePathValueDetector<Root> {
  private let _detect: (Root) -> Bool
  
  public func `is`(_ action: Root) -> Bool {
    _detect(action)
  }
  
  public static func detector<Value>(for casePath: CasePath<Root, Value>) -> CasePathValueDetector {
    CasePathValueDetector(_detect: { casePath.extract(from: $0) == nil })
  }
}

public prefix func / <Root, Value>(
  embed: @escaping (Value) -> Root
) -> CasePathValueDetector<Root> {
  .detector(for: /embed)
}

public prefix func / <Root>(
  case: Root
) -> CasePathValueDetector<Root> {
  .detector(for: /`case`)
}

with TCA to enable dismissOn higher order reducer for handling modals in UIKit (but it may usefull for creating generalized .on(_ action: Action, _ reduce: (inout State, Action, Environment) -> Effect) -> Reducer reducer for example)

public let invitationModalReducer = Reducer<
  Modal<InvitationState>,
  ModalAction<InvitationAction>,
  InvitationEnvironment
>.combine(
  Reducer.modal(
    invitationReducer,
    state: \.self,
    action: /.self,
    environment: { $0 }
  )
  .dismissOn(
    /InvitationAction.confirmChoice,
    /InvitationAction.close
  )
)

it does the same as

public let quizModalReducer = Reducer<
  Modal<QuizState>,
  ModalAction<QuizAction>,
  QuizEnvironment
>.combine(
  Reducer.modal(
    quizReducer,
    state: \.self,
    action: /.self,
    environment: { $0 }
  )
  .lifecycleBasedRouting(/QuizAction.lifecycle)
  .dismissOn(.exit, .timeout, .interactiveTimeout)
}

but the second example has no associated values so I can just pass enum cases.

Method's signatures are

extension Reducer {
  public func dismissOn<LocalAction>(_ actions: LocalAction...) -> Reducer
  where Action == ModalAction<LocalAction>, LocalAction: Equatable { ... }

  public func dismissOn<LocalAction>(_ paths: CasePathValueDetector<LocalAction>...) -> Reducer
  where Action == ModalAction<LocalAction>, LocalAction: Equatable { ... }
}

[maximkrouk]

Maybe you have a better idea for naming 🌚

Implementation of dismissOn method for CasePathValueDetector is

extension Reducer {
  public func dismissOn<LocalAction>(_ paths: CasePathValueDetector<LocalAction>...) -> Reducer
  where Action == ModalAction<LocalAction>, LocalAction: Equatable {
    .combine(
      self,
      Reducer { state, action, environment in
        guard case let .action(action) = action else { return .none}
        for path in paths where path.is(action) {
          return .value(.dismiss)
        }
        return .none
      }
    )
  }
}

[maximkrouk]

Maybe adding AnyCasePath and PartialCasePath will be closer to the KeyPath API, but I decided to fix local problem with a minimal solution without erasing type to Any, but with just hiding the logic into a function, so I probably can just write AnyCasePath and PartialCasePath implementations if needed

[stephencelis]

PartialCasePath was the first thing that came to mind when I saw your original post 😄 I think such a thing could definitely be useful, but it would require us to reconsider things (CasePath is a simple struct, but KeyPath is a class hierarchy). Thanks for bringing this up!

In the meantime we think ad hoc code like you've written in dismissOn is totally cool!

[maximkrouk]

At first, I thought it would be possible to implement using protocols (like AnyCasePath), but this implementation won't allow us to keep KeyPath API, because we won't be able to treat CasePath as PartialCasePath etc, so classes would be required...
Plus the API, in general, will be reconsidered for things like CasePath & WritableCasePath if this separation is needed (maybe even not, also it will lead to major API changes if implemented), so there is definitely some stuff to think about 🤔

[stephencelis]

I think matching KeyPath would be best, which means adopting a class hierarchy, otherwise we'd be force to add operations like eraseToPartialCasePath() and eraseToAnyCasePath(), which wouldn't be ideal.

[maximkrouk]

Also PartialCasePath may be just a simple typealias to CasePath<Root, Any> and AnyCasePath will be CasePath<Any, Any>, the only thing will left to implement is a few / operators...

P.S. Maybe consider moving this issue to Discussions tab, I guess that place fits sharing ideas more 🙂

[stephencelis]

Done!

[maximkrouk]

@stephencelis, any further thoughts about it? 🙂

In my codebase I updated the naming, but maybe you may recommend even more appropriate one

public struct CaseMarker<Root> {
  private let _matches: (Root) -> Bool
  
  public func matches(_ value: Root) -> Bool {
    _matches(value)
  }
  
  public init(matches: @escaping (Root) -> Bool) {
    self._matches = matches
  }
  
  public init<Value>(
    for casePath: CasePath<Root, Value>
  ) {
    self.init { casePath.extract(from: $0).isNotNil }
  }
}

public prefix func / <Root, Value>(
  embed: @escaping (Value) -> Root
) -> CaseMarker<Root> {
  return CaseMarker(for: /embed)
}

public prefix func / <Root>(
  case: Root
) -> CaseMarker<Root> {
  return CaseMarker(for: /`case`)
}

Refreshing thoughts:

• I like that keeping CasePath as structs
• I guess adding a separate type for this functionality is ok
• Maybe it'll be better to use some type-erasure and introduce PartialCasePath

Draft implementation:

public struct PartialCasePath<Root> {
  private let _embed: (Any) -> Root?
  private let _extract: (Root) -> Any?
  
  public init(embed: @escaping (Any) -> Root?, extract: @escaping (Root) -> Any?) {
    self._embed = embed
    self._extract = extract
  }
  
  public func embed(_ value: Any) -> Root? {
    self._embed(value)
  }
  
  public func extract(from root: Root) -> Any? {
    self._extract(root)
  }
  
  public init<Value>(_ casePath: CasePath<Root, Value>) {
    self.init(
      embed: pipe(cast(to: Value.self), map(casePath.embed)),
      extract: casePath.extract
    )
  }
}

func cast<T>(to type: T.Type = T.self) -> (Any) -> T? {
  return { $0 as? T }
}

extension CasePath {
  // probably can avoid force unwrapping by constructing CasePath<Root?, Value?>
  // and providing a way to modify casePath at the call site. I think these transformations
  // need further investigation
  public init(_ partialCasePath: PartialCasePath<Root>) {
    self.init(
      embed: pipe(partialCasePath.embed, \.unsafelyUnwrapped),
      extract: pipe(partialCasePath.extract(from:), { $0 as? Value }, \.unsafelyUnwrapped)
    )
  }
}

public prefix func / <Root, Value>(
  embed: @escaping (Value) -> Root
) -> PartialCasePath<Root> {
  return PartialCasePath(/embed)
}

public prefix func / <Root>(
  case: Root
) -> PartialCasePath<Root> {
  return PartialCasePath(/`case`)
}

extension Reducer {
  public func dismissOn<LocalAction: Equatable>(
    _ paths: PartialCasePath<LocalAction>...
  ) -> Reducer where Action == ModalAction<LocalAction> {
    .combine(
      self,
      Reducer { state, action, environment in
        guard case let .action(action) = action else { return .none }
        return paths.contains { $0.extract(from: action).isNotNil }
          ? Effect(value: .dismiss)
          : .none
      }
    )
  }
}

[maximkrouk]

Also, I remember #27 (comment), where you mentioned that CasePath is a struct so it has some limitations, but maybe it is worth making it a class with some inheritance? It's a major breaking change, and there are a lot of things to think of like naming (CasePath/WritableCasePath or ReadonlyCasePath/CasePath) and equatable conformance, but the implementation of Any/Partial/Readonly casePaths much more straightforward when inheritance is available. At least maybe it is worth creating a separate experimental brunch, I'll probably be able to provide a draft implementation as a proof of concept, so we can continue the investigation in this direction 🙂