Conform AsyncSequence by Shared

[larryonoff]

I believe it would be a convenient improvement to the Shared type if it could conform to AsyncSequence. This enhancement would allow for the use of for-await-in without the need for Combine.

case .onAppear:
  return .run { [currentUser = state.$currentUser] send in
    for await _ in currentUser {
      await send(.currentUserUpdated)
    }
  }

instead of

case .onAppear:
  return .run { [currentUser = state.$currentUser] send in
    for await _ in currentUser.publisher.values {
      await send(.currentUserUpdated)
    }
  }

[mbrandonw]

Hi @larryonoff, I don't think we'd make Shared directly conform to AsyncSequence, just as we didn't confirm it to Publisher. Instead there would be some kind of sequence property to get access to an AsyncSequence, but then at that point is your code that much different?

-for await _ in currentUser.publisher.values {
+for await _ in currentUser.sequence {

Also, this effect can actually be written much shorter for the publisher style:

case .onAppear:
  return .publisher { 
    state.$currentUser.publisher
      .map(.currentUserUpdated)
  }

Because the trailing closure of Effect.publisher is non-escaping you don't have to do the capture dance in order to get access to the shared state.

And finally, the publisher interface was specifically chosen because of its guarantees of synchronous delivery of values, which AsyncSequence cannot guarantee.

[larryonoff]

@mbrandonw The suggestion above is to make public API independent of Combine (which is an Apple-exclusive library). So

for await _ in currentUser.sequence {

looks good.

But maybe it's better to name values instead of sequence, like Publisher.values.

for await _ in currentUser.values {

[mbrandonw]

The suggestion above is to make public API independent of Combine (which is an Apple-exclusive library).

Well TCA is far from being disentangled from Combine. It's on our roadmap, and we want to do it, but there is a lot to figure out before then. So exposing this async sequence doesn't really help much in the grand scheme of running TCA on non-Apple platforms.

[larryonoff]

Indeed. But "small steps towards a big goal"

[mbrandonw]

It's more of a distraction than anything. If you can come up with a tangible benefit to having an async sequence over a publisher we will certainly consider it. But the publisher version of the code is shorter, and guarantees synchronous delivery of data, which is good.

[larryonoff]

My idea was to implement an async sequence using Publisher under-the-hood. However, indeed, this approach is over-engineering. The only advantage of this change is to avoid potential migration issues from Publisher in the future.