Make `each.next` operation a function about effection HOT 3 CLOSED

This poses another question: yielding to a bare object is really cool and pretty to look at but a little confusing to understand. For example yielding to a stream to create a subscription:

function*() {
  const subscription = yield* stream;
}

I wonder if it would be easier for end-users to grok something more like this:

function*() {
  const subscription = yield* stream();
  // or
  const subscription = yield* stream.subscription();
}

Just thinking through the implications of this API change as well as being consistent across-the-board.

from effection.

This is a really interesting point. So basically, you're saying that a stream should be:

type Stream<T, TClose> = () => Operation<Subscription<T, TClose>>;

Or rather stream should stay the same, and that the convention should be to return functions that return them? For example that the type of something likeChannel should be:

interface Channel<T, TClose> {
  //...
  stream(): Stream<T,TClose>;
}

because at the end of the day, a Stream is really just a very specific kind of resource.

I'd almost say that the right call is to have Channel be something like:

interface Channel<T, TClose> {  
  send(value: T): Operation<void>;
  close(value: TClose): Operation<void>;
  subscribe(): Stream<T, TClose>;
}

Which is confusing, but makes sense when you think of what a stream really is which is just an operation that yields a subscription. If we expand the type, it makes more sense.

interface Channel<T, TClose> {
  send(value: T): Operation<void>;
  close(value: TClose): Operation<void>;
  subscribe(): Operation<Subscription<T, TClose>>;
}

Maybe that's the answer?

from effection.

Another option is to make the Stream interface:

interface Stream<T, TClose> {
  subscribe(): Operation<Subscription<T, TClose>>;
}

It's a very small change, but it might reduce confusion by quite a bit. Everything would continue to work the same, but instead of saying yield* stream, you would just say yield* stream.subscribe()

yield* each(stream) would continue continue to work, but any time you're manually iterating a stream it would be a bit less confusing.

from effection.