Add TaskSeq vs AsyncSeq comparison table

Author: abelbraaksma

README.md

@@ -24,15 +24,16 @@ Latest version [can be installed from Nuget][nuget].
   - [`taskSeq` computation expressions](#taskseq-computation-expressions)
   - [Installation](#installation)
   - [Examples](#examples)
-- [Status & planning](#status--planning)
+- [Status \& planning](#status--planning)
   - [Implementation progress](#implementation-progress)
   - [Progress `taskSeq` CE](#progress-taskseq-ce)
   - [Progress and implemented `TaskSeq` module functions](#progress-and-implemented-taskseq-module-functions)
 - [More information](#more-information)
-  - [Further reading `IAsyncEnumerable`](#further-reading-iasyncenumerable)
+  - [The AsyncSeq library](#the-asyncseq-library)
+  - [Further reading on `IAsyncEnumerable`](#further-reading-on-iasyncenumerable)
   - [Further reading on resumable state machines](#further-reading-on-resumable-state-machines)
   - [Further reading on computation expressions](#further-reading-on-computation-expressions)
-- [Building & testing](#building--testing)
+- [Building \& testing](#building--testing)
   - [Prerequisites](#prerequisites)
   - [Build the solution](#build-the-solution)
   - [Run the tests](#run-the-tests)
@@ -332,9 +333,29 @@ The following is the progress report:
 
 ### The AsyncSeq library
 
-If you're looking to use `IAsyncEnumerable` with `async` and not `task`, the existing [`AsyncSeq`][11] library already provides excellent coverage of that use case. While `TaskSeq` is intended to interoperate with `async` as `task` does, it's not intended to provide an `AsyncSeq` type (at least not yet).
-
-In short, if your application is using `Async` (and the parallelism features stemming from that), consider using the `AsyncSeq` library instead.
+The [`AsyncSeq`][11] and `TaskSeq` library both operate on asynchronous sequences, but there are a few fundamental differences, most notably that the former _does not_ implement `IAsyncEnumerable<'T>`, but has its own same-named, but differently behaving type. 
+
+There are more differences:
+
+|                        | `TaskSeq`                                                                         | `AsyncSeq`                                                           |
+|------------------------|-----------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| Frameworks             | .NET 5.0+, NetStandard 2.1                                                        | .NET 5.0+, NetStandard 2.0 and 2.1, .NET Framework 4.6.1+            |
+| Underlying type        | `System.Collections.Generic.IAsyncEnumerable<'T>                                  | Its own type, also called `IAsyncEnumerable<'T>`, but not compatible |
+| Implementation         | State machine (statically compiled)                                               | No state machine, continuation style                                 |
+| Semantics              | `seq`-like: on-demand                                                             | `seq`-like: on-demand                                                |
+| Support `let!`         | All task-like: `Async<'T>`, `task`, `ValueTask<'T>`, `Task<'T>` or `GetAwaiter()` | `Async<'T>` only                                                     |
+| Support `do!`          | `Async<unit>`, `Task<unit>`, `Task`, `ValueTask<unit>`, `ValueTask`               | `Async<unit>` only                                                   |
+| Support `yield!`       | `IAsyncEnumerable<'T>`, `AsyncSeq`, any sequence                                  | `AsyncSeq`                                                           |
+| Support `for`          | `IAsyncEnumerable<'T>`, `AsyncSeq`, any sequence                                  | `AsyncSeq` any sequence                                              |
+| Conversion to other    | `TaskSeq.toAsyncSeq`                                                              | `AsyncSeq.toAsyncEnum`                                               |
+| Conversion from other  | Implicit (yield!) or `TaskSeq.ofAsyncSeq`                                         | `AsyncSeq.ofAsyncEnum`                                               |
+| Recursion in `yield!`  | No (requires F# support, upcoming)                                                | Yes                                                                  |
+| Based on F# concept of | `task`                                                                            | `async`                                                              |
+| MoveNext operation     | `ValueTask<bool>`                                                                 | `Ascyn<'T option>`                                                   |
+| Cancellation           | Implicit token governing iteration                                                | Implicit token passed to each subtask                                |
+| Performance            | Very high, negligible allocations                                                 | Slower, more allocations, due to using `async`                       |
+| Behavior with `Return` | No allocations, no `Task` created                                                 | Allocated, a `Task` will be created                                  |
+| Parallelism            | Possible with ChildTask, support will follow                                      | Supported explicitly                                                 |
 
 ### Further reading on `IAsyncEnumerable`