Implement dynamic versions of the resumable code

[abelbraaksma]

In rare scenarios, for instance, where the resumable code is invoked in a top-level function, the compiler may not be able to compile the resumable code statically. For these cases, we need a dynamic version of the resumable code (which exists, but currently simply raises an exception).

This issues serves as a placeholder for this.

[github-actions]

🤖 This is an automated response from Repo Assist.

Thanks for tracking this — here's a technical read of where the dynamic implementation currently stands and what would be needed.

Current state

When the F# compiler can statically resolve the resumable code (almost always, for top-level taskSeq expressions), it takes the if __useResumableCode then branch and emits a zero-allocation struct state machine via __stateMachine. The else branch raises NotImplementedException with "No dynamic implementation for TaskSeq yet."

In practice the else branch is reached when the taskSeq CE is invoked in a context the compiler cannot statically reduce — most often when the resumable code is passed through higher-order functions or used in a non-trivial way that prevents the static analysis (hence the FS3511 warning and the crash in #269). The compiler already generates a TaskSeqResumptionDynamicInfo<'T> type alias (ResumptionDynamicInfo(TaskSeqStateMachineData<'T)>), and there's a commented-out sketch at line 382–388 of TaskSeqBuilder.fs that points the way.

What the dynamic path needs

The F# task { } CE solves the same problem with a heap-allocated TaskStateMachineData wrapper. The taskSeq dynamic path would need something analogous:

// In the `else` branch of Run:
let initialResumptionFunc = TaskSeqResumptionFunc<'T>(fun sm -> code.Invoke(&sm))

let resumptionFuncExecutor =
    TaskSeqResumptionDynamicInfo<'T>(initialResumptionFunc)

// Then construct a TaskSeqBase<'T> subclass that holds `resumptionFuncExecutor`
// and drives it from IAsyncStateMachine.MoveNext, ManualResetValueTaskSourceCore,
// and the IAsyncEnumerable/IAsyncEnumerator interfaces — similar to TaskSeq<'Machine,'T>
// but without the generic 'Machine type parameter.

The main challenge is that TaskSeq<'Machine, 'T> is generic in 'Machine (which must be an IResumableStateMachine<…> struct — a type the compiler generates statically). In the dynamic path, no such struct exists. You'd need a concrete, non-generic class — call it TaskSeqDynamic<'T> — that:

1. Holds a ResumptionDynamicInfo(TaskSeqStateMachineData<'T)> (the boxed resumption info).
2. Implements IAsyncStateMachine.MoveNext by invoking data.ResumptionData.ResumptionFunc on a heap-allocated TaskSeqStateMachineData<'T>.
3. Forwards all the IValueTaskSource(bool), IAsyncEnumerable<'T>, and IAsyncEnumerator<'T> implementations from TaskSeq<'Machine,'T> — largely copy-paste, since the interfaces don't depend on 'Machine.

The SetStateMachine hook (IAsyncStateMachine.SetStateMachine) would do nothing in the dynamic path (same as in the static path — see the SetStateMachineMethodImpl<_>(fun sm state -> ()) comment in the code).

A note on correctness

The fix in PR #311 (honour CancellationToken in MoveNextAsync) was needed partly because the dynamic path for nested sequences — where a for .. in calls GetAsyncEnumerator — was hitting the unimplemented branch. With the dynamic path itself not throwing, issue #269's NRE should also be resolved. Getting the dynamic path right would be a meaningful improvement to user-facing robustness.

Generated by Repo Assist · ◷

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@5029c9574c7bd2baa70aab6c8de9ea09edf11803