FSharp.Control.TaskSeq/release-notes.txt at main · fsprojects/FSharp.Control.TaskSeq · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

Release notes:

Unreleased
    - fix: `TaskSeq-replicateUntilNoneAsync re-runs the computation from its initial state on each fresh enumeration` test hung CI by declaring its loop counter `n` inside the computation function, so it reset to 0 on every call and the terminating `None` branch was never reached; `n` is now shared across calls as intended
    - test: add SideEffects module to TaskSeq.ReplicateInfinite.Tests.fs and TaskSeq.ThreadState.Tests.fs, verifying computation/generator/folder call counts and re-enumeration semantics
    - test: add direct unit test coverage for the `ValueTask` helper module (`fromResult`, `ofSource`, `ofTask`, `ignore`, `True`/`False`, plus their deprecated aliases), closing a gap where these functions had no dedicated tests despite the `Task`/`Async` equivalents being covered
    - tests: add coverage for side-effect re-execution semantics when re-enumerating a `taskSeq` with independent `CancellationToken`s
    - test: add TaskSeq.Issue452.Tests.fs, regression tests wrapping an externally-produced IAsyncEnumerable<'T> (TaskSeq.map and `taskSeq { for .. in .. do yield .. }`) while running on a custom, single-threaded TaskScheduler; investigates #452's reported duplicated-final-item bug, which could not be reproduced outside of Orleans, see #452
    - adds TaskSeq.tryMax and TaskSeq.tryMin: safe variants of TaskSeq.max and TaskSeq.min that return None instead of raising ArgumentException when the input sequence is empty
    - test: rename `SideEffect` module to `SideEffects` in TaskSeq.Concat.Tests.fs, TaskSeq.Delay.Tests.fs, and TaskSeq.Item.Tests.fs for consistency with the rest of the test suite (50+ files already use the plural form)
    - test: add SideEffects module to TaskSeq.Using.Tests.fs; 7 new tests verify Dispose/DisposeAsync call counts, re-iteration semantics, and early-termination disposal for use and use! CE bindings
    - perf: pairwise, distinctUntilChanged, distinctUntilChangedWith, distinctUntilChangedWithAsync now use explicit enumerator + while! instead of ValueOption tracking + for-in loop, eliminating per-element struct match overhead
    - test: add SideEffects module to TaskSeq.Unfold.Tests.fs, verifying generator call counts, re-iteration behaviour, early-termination via take, and exception propagation
    - test: add SideEffects module to TaskSeq.OfXXX.Tests.fs documenting re-iteration semantics (ofSeq re-evaluates source, ofTaskArray re-awaits cached tasks)
    - adds TaskSeq.foldWhile and TaskSeq.foldWhileAsync: fold with early termination via a (state, element) -> bool predicate (takeWhile-style, exclusive). When the predicate returns false, iteration halts without folding that element; no further elements are enumerated.
    - feat: add `TaskSeq.toChannelAsync` and `TaskSeq.ofChannel` for bidirectional `System.Threading.Channels` integration, closing #415
    - eng: update PackageValidationBaselineVersion from 0.4.0 to 1.1.1 to enforce binary compatibility checks against the current stable release
    - test: add SideEffects module and ImmTaskSeq variant tests to TaskSeq.ChunkBy.Tests.fs, improving coverage for chunkBy and chunkByAsync
    - test: add SideEffects module to TaskSeq.WithCancellation.Tests.fs, verifying re-iteration semantics are preserved when wrapping with a CancellationToken
    - fixes: `Async.bind` signature corrected from `(Async<'T> -> Async<'U>)` to `('T -> Async<'U>)` to match standard monadic bind semantics (same as `Task.bind`); the previous signature made the function effectively equivalent to direct application
    - refactor: simplify splitAt 'rest' taskSeq to use while!, removing redundant go2 mutable and manual MoveNextAsync pre-advance

1.1.1
    - perf: use while! in groupBy, countBy, partition, except, exceptOfSeq to eliminate redundant mutable 'go' variables and initial MoveNextAsync calls

1.1.0
    - adds TaskSeq.chooseV, TaskSeq.chooseVAsync, #385

1.0.0
    - adds taskSeqDynamic computation expression and TaskSeqDynamic/TaskSeqDynamicInfo types for dynamic (FSI-compatible) resumable code, fixing issue where taskSeq would raise NotImplementedException in F# Interactive, #246
    - perf: simplify iter, fold, reduce, mapFold, tryLast, skipOrTake (Drop/Truncate) to use while! and remove manual go-flag and initial MoveNextAsync pre-advance, matching the pattern already used by sum/sumBy/average
    - perf: toResizeArrayAsync (and therefore toArrayAsync, toListAsync, toResizeArrayAsync, toIListAsync) uses a direct loop instead of going through iter, avoiding a lambda and DU allocation per call
    - perf: tryItem uses a simpler loop that skips the redundant inner index check on every iteration
    - perf: TaskSeq.chunkBy and chunkByAsync reuse the ResizeArray buffer between chunks, reducing allocations on sequences with many chunk boundaries
    - fixes: TaskSeq.insertAt, insertManyAt, removeAt, removeManyAt, updateAt now raise ArgumentNullException (not NullReferenceException) when given a null source; insertManyAt also validates the values argument
    - refactor: simplify lengthBy and lengthBeforeMax to use while! and remove the redundant mutable 'go' and initial MoveNextAsync
    - refactor: simplify tryTail inner loop to use while!, removing redundant mutable 'go' flag and initial MoveNextAsync
    - adds TaskSeq.distinctUntilChangedWith and TaskSeq.distinctUntilChangedWithAsync, #345
    - adds TaskSeq.replicateInfinite, replicateInfiniteAsync, replicateUntilNoneAsync, #345
    - adds TaskSeq.firstOrDefault, lastOrDefault, #345
    - adds TaskSeq.splitAt, #345
    - adds TaskSeq.zipWith, zipWithAsync, zipWith3, zipWithAsync3, #345
    - adds TaskSeq.chunkBy, chunkByAsync, #345
    - adds TaskSeq.threadState, threadStateAsync, #345
    - adds docs/ with fsdocs-based documentation site covering generating, transforming, consuming, combining and advanced operations
    - docs: adds missing XML <returns> documentation tags to singleton, isEmpty, length, lengthOrMax, lengthBy, and lengthByAsync
    - test: adds 70 new tests to TaskSeq.Fold.Tests.fs covering call-count assertions, folder-not-called-on-empty, ordering, null initial state, and fold/foldAsync equivalence

1.0.0
    - adds TaskSeq.withCancellation, #167

0.7.0
    - performance: TaskSeq.exists, existsAsync, contains no longer allocate an intermediate Option value
    - test: adds 67 tests for TaskSeq.lengthOrMax (previously untested)
    - adds TaskSeq.mapFold and TaskSeq.mapFoldAsync
    - adds TaskSeq.sum, sumBy, sumByAsync, average, averageBy, averageByAsync
    - adds TaskSeq.reduce and TaskSeq.reduceAsync, #289
    - adds TaskSeq.unfold and TaskSeq.unfoldAsync, #289
    - adds TaskSeq.chunkBySize (closes #258) and TaskSeq.windowed, #289
    - fixes: CancellationToken passed to GetAsyncEnumerator is now honored in MoveNextAsync, #179

0.6.0
    - fixes: async { for item in taskSeq do ... } no longer wraps exceptions in AggregateException, #129
    - eng: enable PackageValidationBaselineVersion=0.4.0 to enforce binary compatibility with last published release
    - adds TaskSeq.compareWith and TaskSeq.compareWithAsync
    - adds TaskSeq.scan and TaskSeq.scanAsync, #289
    - adds TaskSeq.pairwise, #289
    - adds TaskSeq.groupBy and TaskSeq.groupByAsync, #289
    - adds TaskSeq.countBy and TaskSeq.countByAsync, #289
    - adds TaskSeq.partition and TaskSeq.partitionAsync, #289
    - adds TaskSeq.reduce and TaskSeq.reduceAsync, #289
    - adds TaskSeq.unfold and TaskSeq.unfoldAsync, #289
    - adds TaskSeq.distinct, TaskSeq.distinctBy, TaskSeq.distinctByAsync

0.5.0
    - update engineering to .NET 9/10

0.4.0
    - overhaul all doc comments, add exceptions, improve IDE quick-info experience, #136, #220, #234
    - new surface area functions, fixes #208:
      * TaskSeq.take, skip, #209
      * TaskSeq.truncate, drop, #209
      * TaskSeq.where, whereAsync, #217
      * TaskSeq.skipWhile, skipWhileInclusive, skipWhileAsync, skipWhileInclusiveAsync, #219
      * TaskSeq.max, min, maxBy, minBy, maxByAsync, minByAsync, #221
      * TaskSeq.insertAt, insertManyAt, removeAt, removeManyAt, updateAt, #236
      * TaskSeq.forall, forallAsync, #240
      * TaskSeq.concat (overloads: seq, array, resizearray, list), #237

    - Performance: less thread hops with 'StartImmediateAsTask' instead of 'StartAsTask', fixes #135
    - Performance: several inline and allocation improvements
    - BINARY INCOMPATIBILITY: 'TaskSeq' module replaced by static members on 'TaskSeq<_>', fixes #184
    - DEPRECATIONS (warning FS0044):
      - type 'taskSeq<_>' is renamed to 'TaskSeq<_>', fixes #193
      - function 'ValueTask.ofIValueTaskSource` renamed to `ValueTask.ofSource`, fixes #193
      - function `ValueTask.FromResult` is renamed to `ValueTask.fromResult`, fixes #193

0.4.0-alpha.1
    - bugfix: not calling Dispose for 'use!', 'use', or `finally` blocks #157 (by @bartelink)
    - BREAKING CHANGE: null args now raise ArgumentNullException instead of NullReferenceException, #127
    - adds `let!` and `do!` support for F#'s Async<'T>, #79, #114
    - adds TaskSeq.takeWhile, takeWhileAsync, takeWhileInclusive, takeWhileInclusiveAsync, #126 (by @bartelink)
    - adds AsyncSeq vs TaskSeq comparison chart, #131
    - bugfix: removes release-notes.txt from file dependencies, but keep in the package, #138

0.3.0
    - improved xml doc comments, signature files for exposing types, fixes #112.
    - adds support for static TaskLike, allowing the same let! and do! overloads that F# task supports, fixes #110.
    - implements 'do!' for non-generic Task like with Task.Delay, fixes #43.
    - task and async CEs extended with support for 'for .. in ..do' with TaskSeq, #75, #93, #99 (in part by @theangrybyrd).
    - adds TaskSeq.singleton, #90 (by @gusty).
    - bugfix: fixes overload resolution bug with 'use' and 'use!', #97 (thanks @peterfaria).
    - improves TaskSeq.empty by not relying on resumable state, #89 (by @gusty).
    - bugfix: does not throw exceptions anymore for unequal lengths in TaskSeq.zip, fixes #32.
    - BACKWARD INCOMPATIBILITY: several internal-only types now hidden

0.2.2
    - removes TaskSeq.toSeqCachedAsync, which was incorrectly named. Use toSeq or toListAsync instead.
    - renames TaskSeq.toSeqCached to TaskSeq.toSeq, which was its actual operational behavior.

0.2.1
    - fixes an issue with ValueTask on completed iterations.
    - adds `TaskSeq.except` and `TaskSeq.exceptOfSeq` async set operations.

0.2
    - moved from NET 6.0, to NetStandard 2.1 for greater compatibility, no functional changes.
    - move to minimally necessary FSharp.Core version: 6.0.2.
    - updated readme with progress overview, corrected meta info, added release notes.

0.1.1
    - updated meta info in nuget package and added readme.

0.1
    - initial release
    - implements taskSeq CE using resumable state machines
        - with support for: yield, yield!, let, let!, while, for, try-with, try-finally, use, use!
        - and: tasks and valuetasks
    - adds toXXX / ofXXX functions
    - adds map/mapi/fold/iter/iteri/collect etc with async variants
    - adds find/pick/choose/filter etc with async variants and 'try' variants
    - adds cast/concat/append/prepend/delay/exactlyOne
    - adds empty/isEmpty
    - adds findIndex/indexed/init/initInfinite
    - adds head/last/tryHead/tryLast/tail/tryTail
    - adds zip/length