`yield* task.halt()` from the same task is a self-join

[dcolascione]

Upstream test/run.test.ts currently has these tests:

• can halt itself
• can halt itself between yield points

Both call yield* task.halt() from inside the task being halted.

That seems like a broken API pattern. halt() requests cancellation and waits for the task's teardown to finish. If the task itself is yielding on that drain, teardown cannot finish until the current generator unwinds. That's a self-join.

Minimal shape:

let task: Task<void> = run(function* () {
  yield* sleep(0);
  yield* task.halt();
});

await task;

I think self-cancel needs a request-only operation instead, e.g. task.requestHalt() / task.requestCancel(), with task.halt() kept as the external request-and-drain API.

If yield* task.halt() from inside the same task is intentionally unsupported, it would be useful for Effection to document that or reject it with a clear error instead of treating it as normal cancellation behavior.

[cowboyd]

That seems like a broken API pattern.

I agree. It has been supported since v1, but not strongly. In reality, it has carried forward into version 4 via inertia more than anything else. IIRC, the original rationale was that because it was "possible", then it should be "doable."

Looking at it now, however, it feels like this should be a hard exception. I have personally done this precisely zero times in almost ten years, and I would look very critically on any code that came across my desk doing so.

Thank you for taking to report all these things. They very helpful, and I wish only that I could fix them more quickly.

[cowboyd]

I think step one is disallowing self-join entirely. #1162

For cases where a task wishes to request its own cancellation, that is certainly doable within user-land. We could consider moving it into core at a later point.