Rename TaskSeq.toSeqCached -> toSeq and remove TaskSeq.toSeqCachedAsync, which simply didn't make much sense

Author: abelbraaksma

src/FSharp.Control.TaskSeq.Test/TaskSeq.Append.Tests.fs

@@ -17,8 +17,8 @@ open System.Collections.Generic
 
 let validateSequence ts =
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal "1234567891012345678910")
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.Cast.Tests.fs

@@ -17,8 +17,8 @@ open FSharp.Control
 /// Asserts that a sequence contains the char values 'A'..'J'.
 let validateSequence ts =
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal "12345678910")
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.Collect.Tests.fs

@@ -102,8 +102,8 @@ module Immutable =
 
     let validateSequence ts =
         ts
-        |> TaskSeq.toSeqCachedAsync
-        |> Task.map (Seq.map string)
+        |> TaskSeq.toListAsync
+        |> Task.map (List.map string)
         |> Task.map (String.concat "")
         |> Task.map (should equal "ABBCCDDEEFFGGHHIIJJK")
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.Concat.Tests.fs

@@ -15,8 +15,8 @@ open System.Collections.Generic
 
 let validateSequence ts =
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal "123456789101234567891012345678910")
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.Delay.Tests.fs

@@ -15,8 +15,8 @@ open System.Collections.Generic
 
 let validateSequence ts =
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal "12345678910")
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.Empty.Tests.fs

@@ -10,7 +10,7 @@ open FSharp.Control
 
 [<Fact>]
 let ``TaskSeq-empty returns an empty sequence`` () = task {
-    let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
+    let! sq = TaskSeq.empty<string> |> TaskSeq.toListAsync
     Seq.isEmpty sq |> should be True
     Seq.length sq |> should equal 0
 }

src/FSharp.Control.TaskSeq.Test/TaskSeq.Map.Tests.fs

@@ -16,8 +16,8 @@ open FSharp.Control
 /// Asserts that a sequence contains the char values 'A'..'J'.
 let validateSequence ts =
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal "ABCDEFGHIJ")
 
@@ -29,8 +29,8 @@ let validateSequenceWithOffset offset ts =
         |> String.concat ""
 
     ts
-    |> TaskSeq.toSeqCachedAsync
-    |> Task.map (Seq.map string)
+    |> TaskSeq.toListAsync
+    |> Task.map (List.map string)
     |> Task.map (String.concat "")
     |> Task.map (should equal expected)
 

src/FSharp.Control.TaskSeq.Test/TaskSeq.ToXXX.Tests.fs

@@ -35,13 +35,6 @@ module EmptySeq =
         results |> should be Empty
     }
 
-    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
-    let ``TaskSeq-toSeqCachedAsync with empty`` variant = task {
-        let tq = Gen.getEmptyVariant variant
-        let! (results: seq<_>) = tq |> TaskSeq.toSeqCachedAsync
-        results |> Seq.toArray |> should be Empty
-    }
-
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-toIListAsync with empty`` variant = task {
         let tq = Gen.getEmptyVariant variant
@@ -71,7 +64,7 @@ module EmptySeq =
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-toSeqCached with empty`` variant =
         let tq = Gen.getEmptyVariant variant
-        let (results: seq<_>) = tq |> TaskSeq.toSeqCached
+        let (results: seq<_>) = tq |> TaskSeq.toSeq
         results |> Seq.toArray |> should be Empty
 
 module Immutable =
@@ -90,13 +83,6 @@ module Immutable =
         results |> should equal [ 1..10 ]
     }
 
-    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
-    let ``TaskSeq-toSeqCachedAsync should succeed`` variant = task {
-        let tq = Gen.getSeqImmutable variant
-        let! (results: seq<_>) = tq |> TaskSeq.toSeqCachedAsync
-        results |> Seq.toArray |> should equal [| 1..10 |]
-    }
-
     [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
     let ``TaskSeq-toIListAsync should succeed`` variant = task {
         let tq = Gen.getSeqImmutable variant
@@ -126,7 +112,7 @@ module Immutable =
     [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
     let ``TaskSeq-toSeqCached should succeed and be blocking`` variant =
         let tq = Gen.getSeqImmutable variant
-        let (results: seq<_>) = tq |> TaskSeq.toSeqCached
+        let (results: seq<_>) = tq |> TaskSeq.toSeq
         results |> Seq.toArray |> should equal [| 1..10 |]
 
 
@@ -159,15 +145,6 @@ module SideEffects =
         results2 |> should equal [ 11..20 ]
     }
 
-    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
-    let ``TaskSeq-toSeqCachedAsync should execute side effects multiple times`` variant = task {
-        let tq = Gen.getSeqWithSideEffect variant
-        let! (results1: seq<_>) = tq |> TaskSeq.toSeqCachedAsync
-        let! (results2: seq<_>) = tq |> TaskSeq.toSeqCachedAsync
-        results1 |> Seq.toArray |> should equal [| 1..10 |]
-        results2 |> Seq.toArray |> should equal [| 11..20 |]
-    }
-
     [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
     let ``TaskSeq-toIListAsync should execute side effects multiple times`` variant = task {
         let tq = Gen.getSeqWithSideEffect variant
@@ -205,7 +182,7 @@ module SideEffects =
     [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
     let ``TaskSeq-toSeqCached should execute side effects multiple times`` variant =
         let tq = Gen.getSeqWithSideEffect variant
-        let (results1: seq<_>) = tq |> TaskSeq.toSeqCached
-        let (results2: seq<_>) = tq |> TaskSeq.toSeqCached
+        let (results1: seq<_>) = tq |> TaskSeq.toSeq
+        let (results2: seq<_>) = tq |> TaskSeq.toSeq
         results1 |> Seq.toArray |> should equal [| 1..10 |]
         results2 |> Seq.toArray |> should equal [| 11..20 |]

src/FSharp.Control.TaskSeq.Test/TestUtils.fs

@@ -138,8 +138,8 @@ type DummyTaskFactory(µsecMin: int64<µs>, µsecMax: int64<µs>) =
 module TestUtils =
     let verifyEmpty ts =
         ts
-        |> TaskSeq.toSeqCachedAsync
-        |> Task.map (Seq.isEmpty >> should be True)
+        |> TaskSeq.toArrayAsync
+        |> Task.map (Array.isEmpty >> should be True)
 
     /// Delays (no spin-wait!) between 20 and 70ms, assuming a 15.6ms resolution clock
     let longDelay () = task { do! Task.Delay(Random().Next(20, 70)) }

src/FSharp.Control.TaskSeq/FSharp.Control.TaskSeq.fsproj

@@ -8,9 +8,11 @@
     <Title>Computation expression 'taskSeq' for processing IAsyncEnumerable sequences and module functions</Title>
     <Version>$(Version)</Version>
     <Authors>Abel Braaksma; Don Syme</Authors>
-    <Description>Provides the 'taskSeq' computation expression to support performance and statially optimized async sequences using the new F# 6.0 resumable state machines, similar to 'task'. 
+    <Description>This library brings C#'s concept of 'await foreach' to F#.
 
-This library brings C#'s concept of 'await foreach' to F#.</Description>
+The 'taskSeq' computation expression adds support for awaitable asyncronous sequences with a similar ease of use and performance as F#'s 'task' CE. TaskSeq brings 'seq' and 'task' together in a safe way.
+
+Generates optimized IL code and comes with a comprehensive set of module functions. See README for more info.</Description>
     <Copyright>Copyright 2022</Copyright>
     <PackageProjectUrl>https://github.com/fsprojects/FSharp.Control.TaskSeq</PackageProjectUrl>
     <RepositoryUrl>https://github.com/fsprojects/FSharp.Control.TaskSeq</RepositoryUrl>
@@ -20,20 +22,39 @@ This library brings C#'s concept of 'await foreach' to F#.</Description>
     <PackageRequireLicenseAcceptance>False</PackageRequireLicenseAcceptance>
     <PackageReadmeFile>nuget-package-readme.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      v.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
-      v.0.1.1
-       - updated meta info in nuget package and added readme
-      v.0.1
+      Release notes:
+      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
+       
     </PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>
     <Content Include="..\..\assets\TaskSeq.ico" Link="TaskSeq.ico" />
-    <None Include="..\..\taskseq-icon.png">
+    <None Include="..\..\assets\taskseq-icon.png">
       <Pack>True</Pack>
       <PackagePath>\</PackagePath>
     </None>

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -46,7 +46,7 @@ module TaskSeq =
             e.DisposeAsync().AsTask().Wait()
     |]
 
-    let toSeqCached (source: taskSeq<'T>) = seq {
+    let toSeq (source: taskSeq<'T>) = seq {
         let e = source.GetAsyncEnumerator(CancellationToken())
 
         try
@@ -66,8 +66,6 @@ module TaskSeq =
 
     let toIListAsync source = Internal.toResizeArrayAndMapAsync (fun x -> x :> IList<_>) source
 
-    let toSeqCachedAsync source = Internal.toResizeArrayAndMapAsync (fun x -> x :> seq<_>) source
-
     //
     // Convert 'OfXXX' functions
     //

src/FSharp.Control.TaskSeq/TaskSeq.fsi

@@ -154,8 +154,16 @@ module TaskSeq =
     /// Returns taskSeq as an array. This function is blocking until the sequence is exhausted and will properly dispose of the resources.
     val toArray: source: taskSeq<'T> -> 'T[]
 
-    /// Returns taskSeq as a seq, similar to Seq.cached. This function is blocking until the sequence is exhausted and will properly dispose of the resources.
-    val toSeqCached: source: taskSeq<'T> -> seq<'T>
+    /// <summary>
+    /// Returns the task sequence <paramref name="source" /> as an F# <see cref="seq" />, that is, an
+    /// <see cref="IEnumerable&lt;'T>" />. This function is blocking at each <see cref="yield" />, but otherwise
+    /// acts as a normal delay-executed sequence.
+    /// It will then dispose of the resources.
+    /// </summary>
+    ///
+    /// <param name="source">The input task sequence.</param>
+    /// <returns>The resulting task sequence.</returns>
+    val toSeq: source: taskSeq<'T> -> seq<'T>
 
     /// Unwraps the taskSeq as a Task<array<_>>. This function is non-blocking.
     val toArrayAsync: source: taskSeq<'T> -> Task<'T[]>
@@ -169,10 +177,6 @@ module TaskSeq =
     /// Unwraps the taskSeq as a Task<IList<_>>. This function is non-blocking.
     val toIListAsync: source: taskSeq<'T> -> Task<IList<'T>>
 
-    /// Unwraps the taskSeq as a Task<seq<_>>. This function is non-blocking,
-    /// exhausts the sequence and caches the results of the tasks in the sequence.
-    val toSeqCachedAsync: source: taskSeq<'T> -> Task<seq<'T>>
-
     /// Create a taskSeq of an array.
     val ofArray: source: 'T[] -> taskSeq<'T>