From a9a147e74971597f5082c98a773774ffd739d2bb Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Mar 2026 19:07:43 +0000 Subject: [PATCH 1/2] docs: update README to mark 0.6.0 functions as implemented MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mark as implemented (✅) following the wave of PRs merged for v0.6.0: - TaskSeq.average, averageBy, averageByAsync (#304) - TaskSeq.sum, sumBy, sumByAsync (#304) - TaskSeq.distinct, distinctBy, distinctByAsync, distinctUntilChanged (#305) - TaskSeq.mapFold, mapFoldAsync (#306) - TaskSeq.groupBy, groupByAsync (#307) - TaskSeq.countBy, countByAsync — add missing table row (#307) - TaskSeq.partition, partitionAsync — add missing table row (#307) Also: - Fix typo 'dictinctBy' → 'distinctBy' - Update 'Status & planning' checklist to reflect completed work - Add PR link definitions (#304–#307) at the bottom Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- README.md | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index dcc1cbf..3a7f37b 100644 --- a/README.md +++ b/README.md @@ -208,16 +208,16 @@ The `TaskSeq` project already has a wide array of functions and functionalities, - [ ] Add remaining relevant functions from `Seq`. **PLANNED FOR 0.4.x** - [x] `min` / `max` / `minBy` / `maxBy` & async variant (see [#221]) - [x] `insertAt` / `updateAt` and related (see [#236]) - - [ ] `average` / `averageBy`, `sum` and related + - [x] `average` / `averageBy`, `sum` and related (see [#304]) - [x] `forall` / `forallAsync` (see [#240]) - [x] `skip` / `drop` / `truncate` / `take` (see [#209]) - [x] `chunkBySize` / `windowed` (see [#258]) - [ ] `compareWith` - - [ ] `distinct` + - [x] `distinct` / `distinctBy` (see [#305]) - [ ] `exists2` / `map2` / `fold2` / `iter2` and related '2'-functions - - [ ] `mapFold` + - [x] `mapFold` (see [#306]) - [x] `pairwise` (see [#293]) - - [ ] `allpairs` / `permute` / `distinct` / `distinctBy` + - [x] `groupBy` / `groupByAsync`, `countBy` / `countByAsync`, `partition` / `partitionAsync` (see [#307]) - [x] `replicate` - [x] `reduce` / `scan` (see [#299], [#296]) - [x] `unfold` (see [#300]) @@ -257,8 +257,8 @@ This is what has been implemented so far, is planned or skipped: | ✅ [#81][] | `append` | `append` | | | | ✅ [#81][] | | | `appendSeq` | | | ✅ [#81][] | | | `prependSeq` | | -| | `average` | `average` | | | -| | `averageBy` | `averageBy` | `averageByAsync` | | +| ✅ [#304][] | `average` | `average` | | | +| ✅ [#304][] | `averageBy` | `averageBy` | `averageByAsync` | | | ❓ | `cache` | `cache` | | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") | | ✅ [#67][] | `cast` | `cast` | | | | ✅ [#67][] | | | `box` | | @@ -274,9 +274,11 @@ This is what has been implemented so far, is planned or skipped: | ✅ [#237][]| `concat` (r-array) | `concat` (r-array) | | | | ✅ [#237][]| `concat` (seq) | `concat` (seq) | | | | ✅ [#70][] | `contains` | `contains` | | | +| ✅ [#307][] | `countBy` | `countBy` | `countByAsync` | | | ✅ [#82][] | `delay` | `delay` | | | -| | `distinct` | `distinct` | | | -| | `distinctBy` | `dictinctBy` | `distinctByAsync` | | +| ✅ [#305][] | `distinct` | `distinct` | | | +| ✅ [#305][] | `distinctBy` | `distinctBy` | `distinctByAsync` | | +| ✅ [#305][] | | `distinctUntilChanged` | | | | ✅ [#209][]| | `drop` | | | | ✅ [#2][] | `empty` | `empty` | | | | ✅ [#23][] | `exactlyOne` | `exactlyOne` | | | @@ -295,7 +297,7 @@ This is what has been implemented so far, is planned or skipped: | 🚫 | `foldBack2` | | | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") | | ✅ [#240][]| `forall` | `forall` | `forallAsync` | | | | `forall2` | `forall2` | `forall2Async` | | -| ❓ | `groupBy` | `groupBy` | `groupByAsync` | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") | +| ✅ [#307][] | `groupBy` | `groupBy` | `groupByAsync` | | | ✅ [#23][] | `head` | `head` | | | | ✅ [#68][] | `indexed` | `indexed` | | | | ✅ [#69][] | `init` | `init` | `initAsync` | | @@ -314,7 +316,7 @@ This is what has been implemented so far, is planned or skipped: | ✅ [#2][] | `map` | `map` | `mapAsync` | | | | `map2` | `map2` | `map2Async` | | | | `map3` | `map3` | `map3Async` | | -| | `mapFold` | `mapFold` | `mapFoldAsync` | | +| ✅ [#306][] | `mapFold` | `mapFold` | `mapFoldAsync` | | | 🚫 | `mapFoldBack` | | | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") | | ✅ [#2][] | `mapi` | `mapi` | `mapiAsync` | | | | `mapi2` | `mapi2` | `mapi2Async` | | @@ -334,6 +336,7 @@ This is what has been implemented so far, is planned or skipped: | ✅ [#2][] | | `ofTaskList` | | | | ✅ [#2][] | | `ofTaskSeq` | | | | ✅ [#293][] | `pairwise` | `pairwise` | | | +| ✅ [#307][] | `partition` | `partition` | `partitionAsync` | | | | `permute` | `permute` | `permuteAsync` | | | ✅ [#23][] | `pick` | `pick` | `pickAsync` | | | 🚫 | `readOnly` | | | [note #3](#note3 "The motivation for 'readOnly' in 'Seq' is that a cast from a mutable array or list to a 'seq<_>' is valid and can be cast back, leading to a mutable sequence. Since 'TaskSeq' doesn't implement 'IEnumerable<_>', such casts are not possible.") | @@ -355,8 +358,8 @@ This is what has been implemented so far, is planned or skipped: | ❓ | `sortByDescending` | | | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") | | ❓ | `sortWith` | | | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") | | | `splitInto` | `splitInto` | | | -| | `sum` | `sum` | | | -| | `sumBy` | `sumBy` | `sumByAsync` | | +| ✅ [#304][] | `sum` | `sum` | | | +| ✅ [#304][] | `sumBy` | `sumBy` | `sumByAsync` | | | ✅ [#76][] | `tail` | `tail` | | | | ✅ [#209][]| `take` | `take` | | | | ✅ [#126][]| `takeWhile` | `takeWhile` | `takeWhileAsync` | | @@ -659,6 +662,10 @@ module TaskSeq = [#296]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/296 [#299]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/299 [#300]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/300 +[#304]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/304 +[#305]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/305 +[#306]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/306 +[#307]: https://github.com/fsprojects/FSharp.Control.TaskSeq/pull/307 [issues]: https://github.com/fsprojects/FSharp.Control.TaskSeq/issues [nuget]: https://www.nuget.org/packages/FSharp.Control.TaskSeq/ From 865743115086e2bf91b7a2f1cbe441061cbe5329 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Mar 2026 19:20:44 +0000 Subject: [PATCH 2/2] ci: trigger checks