Cleanup whileasync (#44)

* cleanup whileasync * WIP * Move whileasync priority * Fix tfms * ensure source members have distinct overloads * delete playground * delete playground
TheAngryByrd · Apr 6, 2024 · c78fd63 · c78fd63
1 parent 4a903d9
commit c78fd63
Show file tree

Hide file tree

Showing 11 changed files with 280 additions and 463 deletions.
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -10,5 +10,9 @@
         <!-- owners is not supported in MSBuild -->
         <OtherFlags>$(OtherFlags) --test:GraphBasedChecking --test:ParallelIlxGen --test:ParallelOptimization </OtherFlags>
         <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+       <!--
+        * FS3517 InlineIfLambda didn't get inlined
+        -->
+        <!-- <WarnOn>$(WarnOn);3517</WarnOn> -->
     </PropertyGroup>
 </Project>
diff --git a/docsSrc/index.md b/docsSrc/index.md
@@ -63,7 +63,6 @@ AsyncEx is similar to Async except in the following ways:
     ```
 3. When Tasks throw exceptions they will use the behavior described in [Async.Await overload (esp. AwaitTask without throwing AggregateException](https://github.com/fsharp/fslang-suggestions/issues/840)
 
-
     ```fsharp
     let data = "lol"
 
@@ -89,10 +88,8 @@ AsyncEx is similar to Async except in the following ways:
             return raise (Exception("Should not throw this type of exception", ex))
     }
     ```
-
 4. Use [IAsyncEnumerable](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.iasyncenumerable-1?view=net-8.0) with `for` keyword. This example uses [TaskSeq](https://github.com/fsprojects/FSharp.Control.TaskSeq) but you can use any `IAsyncEnumerable<T>`.
 
-
     ```fsharp
     open IcedTasks
     open FSharp.Control

diff --git a/msbuild.binlog b/msbuild.binlog
diff --git a/src/IcedTasks/CancellableTaskBuilderBase.fs b/src/IcedTasks/CancellableTaskBuilderBase.fs
diff --git a/src/IcedTasks/TaskBuilderBase.fs b/src/IcedTasks/TaskBuilderBase.fs
diff --git a/tests/IcedTasks.Tests/CancellablePoolingValueTaskTests.fs b/tests/IcedTasks.Tests/CancellablePoolingValueTaskTests.fs
@@ -805,7 +805,7 @@ module CancellablePoolingValueTaskTests =
 
                             let! actual =
                                 cancellablePoolingValueTask {
-                                    for (i: int) in asyncSeq do
+                                    for i in asyncSeq do
                                         do! Task.Yield()
                                         index <- i + i
 
@@ -967,10 +967,10 @@ module CancellablePoolingValueTaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             cancellablePoolingValueTask {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }
 

diff --git a/tests/IcedTasks.Tests/CancellableTaskTests.fs b/tests/IcedTasks.Tests/CancellableTaskTests.fs
@@ -926,10 +926,10 @@ module CancellableTaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             cancellableTask {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }
 

diff --git a/tests/IcedTasks.Tests/CancellableValueTaskTests.fs b/tests/IcedTasks.Tests/CancellableValueTaskTests.fs
@@ -963,10 +963,10 @@ module CancellableValueTaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             cancellableValueTask {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }
 

diff --git a/tests/IcedTasks.Tests/PoolingValueTaskTests.fs b/tests/IcedTasks.Tests/PoolingValueTaskTests.fs
@@ -690,10 +690,10 @@ module PoolingValueTaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             poolingValueTask {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }
 

diff --git a/tests/IcedTasks.Tests/TaskTests.fs b/tests/IcedTasks.Tests/TaskTests.fs
@@ -693,10 +693,10 @@ module TaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             task {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }
 

diff --git a/tests/IcedTasks.Tests/ValueTaskTests.fs b/tests/IcedTasks.Tests/ValueTaskTests.fs
@@ -690,10 +690,10 @@ module ValueTaskTests =
 
                         let doOtherStuff (l: ResizeArray<_>) x =
                             valueTask {
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 do! Task.yieldMany 1000
                                 let dt = DateTimeOffset.UtcNow
-                                l.Add(x)
+                                lock l (fun () -> l.Add(x))
                                 return dt
                             }