We want design parity with FSharp.Control.AsyncSeq

[dsyme]

/repo-assist We want design parity between FSharp.Control.AsyncSeq and FSharp.Control.TaskSeq.

https://github.com/fsprojects/FSharp.Control.AsyncSeq

One difference is withCancellation is missing from FSharp.Control.AsyncSeq but more research about reaching design parity is needed. Look into what's needed for TaskSeq here.

[github-actions]

🤖 This is an automated response from Repo Assist.

Great research topic! Here is a systematic gap analysis comparing FSharp.Control.AsyncSeq (commit 7c774fe) against the current FSharp.Control.TaskSeq 1.0.0.

---

Functions in AsyncSeq but NOT in TaskSeq

Group 1 — Pure sequence operations (natural fits for TaskSeq)

AsyncSeq function	Notes
chunkBy / chunkByAsync	Groups consecutive elements by a key, yielding (key * 'T list) pairs. Complements the existing chunkBySize.
distinctUntilChangedWith / distinctUntilChangedWithAsync	Custom equality predicate for the existing distinctUntilChanged. Straightforward addition.
firstOrDefault default	Convenience over tryHead >> Option.defaultValue. AsyncSeq also has lastOrDefault.
lastOrDefault default	Same as above for the last element.
splitAt count	Returns (firstN array * remaining TaskSeq) — single-pass; unlike take+skip which require two separate enumerations.
zipWith mapping / zipWithAsync mapping	zip then map as a single pass; avoids an intermediate tuple allocation. Also zipWith3/zipWithAsync3.
replicateInfinite value	Convenience over initInfinite (fun _ -> value).
replicateInfiniteAsync computation	Same for async computations.
replicateUntilNoneAsync computation	Emits elements until the async computation returns None.
threadStateAsync folder state	Stateful async map: ('State -> 'T -> Task<'U * 'State>) -> 'State -> TaskSeq<'T> -> TaskSeq<'U>. Useful for carrying accumulated state through a stream.

Group 2 — Materialise-and-sort / reverse (design question)

AsyncSeq has rev, sort, sortBy, sortByDescending, sortWith, sortDescending.
These were proposed for TaskSeq in PR #309 / PR #316 and the decision was not to add them. Noting here for completeness.
AsyncSeq returns array<'T> (not AsyncSeq<'T>) from these — a notable design difference from Seq.

Group 3 — Reactive / concurrent / streaming

These exist in AsyncSeq but require concurrent scheduling, making them substantially heavier to implement reliably:

Function	What it does
merge / mergeAll / mergeChoice	Concurrent stream merging
interleave / interleaveChoice / interleaveMany	Round-robin interleaving
combineLatest / combineLatestWith / combineLatestWithAsync	Latest-value combination (reactive style)
bufferByCount / bufferByCountAndTime / bufferByTime	Time-window buffering
intervalMs	Timer-based element emission
takeUntil / takeWhileAsync / skipUntil	Async signal-based control
mapAsyncParallel / mapAsyncUnorderedParallel / …	Parallel map variants (related to #143)
iterAsyncParallel / iterAsyncParallelThrottled	Parallel iter variants
zipParallel / zipWithParallel / zipWithAsyncParallel	Parallel zip

Group 4 — Not applicable to TaskSeq

AsyncSeq function	Reason not applicable
asyncSeq builder	Replaced by taskSeq
toBlockingSeq / toArraySynchronously / toListSynchronously	TaskSeq already has synchronous toArray / toList
toAsyncEnum / ofAsyncEnum	TaskSeq is IAsyncEnumerable<'T> natively
toAsyncSeq / ofSeqAsync	Cross-library concern
ofObservable / ofObservableBuffered / toObservable	Requires System.Reactive or similar dependency
fromChannel / toChannel / put	System.Threading.Channels specific
zapp / zappAsync	Applicative-style, very niche
cache	Tricky with IAsyncEnumerable reset semantics — needs discussion
getIterator / close / create / error	AsyncSeq implementation internals

---

Functions in TaskSeq but NOT in AsyncSeq (TaskSeq advantages)

TaskSeq 1.0.0 has several combinators that AsyncSeq lacks — these represent places where TaskSeq already exceeds AsyncSeq:

TaskSeq function	Notes
withCancellation	Just added in 1.0.0! Explicitly passes a CancellationToken to GetAsyncEnumerator. AsyncSeq handles this via the Async ambient token.
partition / partitionAsync	Single-pass split into two arrays; no AsyncSeq equivalent.
appendSeq / prependSeq	Interop with regular seq<'T>; AsyncSeq has concatSeq but not separate prepend.
skipWhileInclusive / takeWhileInclusive + async	Inclusive predicate scanning; AsyncSeq lacks these.
compareWith / compareWithAsync	Lexicographic comparison returning int.
tryTail	Optional tail; AsyncSeq has tail (throws on empty).
box / unbox / cast	Type coercions.
lengthOrMax / lengthBy / lengthByAsync	Bounded and predicated length.
drop	Non-throwing skip alias (explicit no-throw semantics).
exceptOfSeq	Except against a regular seq<'T>.
collectSeq / collectSeqAsync	Collect/flatMap against a seq<'T> projection.
insertManyAt / removeManyAt	Multi-element positional ops.
Rich ofArray / ofList / ofResizeArray / ofTaskSeq / ofTaskList / ofTaskArray / ofAsyncSeq / ofAsyncList / ofAsyncArray	AsyncSeq has fewer conversion sources.
toIListAsync / toResizeArrayAsync	Additional materialisation targets.

---

Summary

The most tractable items for design parity (in order of ease and value) are in Group 1 above: chunkBy, distinctUntilChangedWith, zipWith, firstOrDefault/lastOrDefault, splitAt, replicateInfinite/replicateUntilNoneAsync, and threadStateAsync. These are all pure sequential operations with clear semantics.

The reactive/concurrent group (Group 3) would be a larger design investment and may or may not be in scope — that seems worth a separate discussion.

Generated by Repo Assist for issue #345 · ◷

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@346204513ecfa08b81566450d7d599556807389f