Turn TaskSeq.empty into a unit-function

src/FSharpy.TaskSeq.Test/TaskSeq.Choose.Tests.fs

@@ -19,7 +19,7 @@ let ``ZHang timeout test`` () = task {
 [<Fact>]
 let ``TaskSeq-choose on an empty sequence`` () = task {
     let! empty =
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.choose (fun _ -> Some 42)
         |> TaskSeq.toListAsync
 
@@ -29,7 +29,7 @@ let ``TaskSeq-choose on an empty sequence`` () = task {
 [<Fact>]
 let ``TaskSeq-chooseAsync on an empty sequence`` () = task {
     let! empty =
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.chooseAsync (fun _ -> task { return Some 42 })
         |> TaskSeq.toListAsync
 

src/FSharpy.TaskSeq.Test/TaskSeq.Collect.Tests.fs

@@ -60,6 +60,6 @@ let ``TaskSeq-collectSeq with empty sequences`` () = task {
 
 [<Fact>]
 let ``TaskSeq-empty is empty`` () = task {
-    let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
+    let! sq = TaskSeq.empty<string> () |> TaskSeq.toSeqCachedAsync
     Seq.isEmpty sq |> should be True
 }

src/FSharpy.TaskSeq.Test/TaskSeq.Filter.Tests.fs

@@ -10,7 +10,7 @@ open FSharpy
 [<Fact>]
 let ``TaskSeq-filter on an empty sequence`` () = task {
     let! empty =
-        TaskSeq.empty
+        TaskSeq.empty()
         |> TaskSeq.filter ((=) 12)
         |> TaskSeq.toListAsync
 
@@ -20,7 +20,7 @@ let ``TaskSeq-filter on an empty sequence`` () = task {
 [<Fact>]
 let ``TaskSeq-filterAsync on an empty sequence`` () = task {
     let! empty =
-        TaskSeq.empty
+        TaskSeq.empty()
         |> TaskSeq.filterAsync (fun x -> task { return x = 12 })
         |> TaskSeq.toListAsync
 

src/FSharpy.TaskSeq.Test/TaskSeq.Find.Tests.fs

@@ -15,7 +15,7 @@ open System.Collections.Generic
 
 [<Fact>]
 let ``TaskSeq-find on an empty sequence raises KeyNotFoundException`` () = task {
-    fun () -> TaskSeq.empty |> TaskSeq.find ((=) 12) |> Task.ignore
+    fun () -> TaskSeq.empty () |> TaskSeq.find ((=) 12) |> Task.ignore
     |> should throwAsyncExact typeof<KeyNotFoundException>
 }
 
@@ -28,7 +28,7 @@ let ``TaskSeq-find on an empty sequence raises KeyNotFoundException - variant``
 [<Fact>]
 let ``TaskSeq-findAsync on an empty sequence raises KeyNotFoundException`` () = task {
     fun () ->
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.findAsync (fun x -> task { return x = 12 })
         |> Task.ignore
     |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -136,14 +136,14 @@ let ``TaskSeq-findAsync happy path last item of seq`` () = task {
 
 [<Fact>]
 let ``TaskSeq-tryFind on an empty sequence returns None`` () = task {
-    let! nothing = TaskSeq.empty |> TaskSeq.tryFind ((=) 12)
+    let! nothing = TaskSeq.empty () |> TaskSeq.tryFind ((=) 12)
     nothing |> should be None'
 }
 
 [<Fact>]
 let ``TaskSeq-tryFindAsync on an empty sequence returns None`` () = task {
     let! nothing =
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.tryFindAsync (fun x -> task { return x = 12 })
 
     nothing |> should be None'

src/FSharpy.TaskSeq.Test/TaskSeq.Fold.Tests.fs

@@ -33,7 +33,7 @@ let ``TaskSeq-foldAsync folds with every item`` () = task {
 [<Fact>]
 let ``TaskSeq-fold takes state on empty IAsyncEnumberable`` () = task {
     let! empty =
-        TaskSeq.empty
+        TaskSeq.empty()
         |> TaskSeq.fold (fun _ item -> char (item + 64)) '_'
 
     empty |> should equal '_'
@@ -42,7 +42,7 @@ let ``TaskSeq-fold takes state on empty IAsyncEnumberable`` () = task {
 [<Fact>]
 let ``TaskSeq-foldAsync takes state on empty IAsyncEnumerable`` () = task {
     let! alphabet =
-        TaskSeq.empty
+        TaskSeq.empty()
         |> TaskSeq.foldAsync (fun _ item -> task { return char (item + 64) }) '_'
 
     alphabet |> should equal '_'

src/FSharpy.TaskSeq.Test/TaskSeq.Head.Tests.fs

@@ -10,7 +10,7 @@ open FSharpy
 
 [<Fact>]
 let ``TaskSeq-head throws on empty sequences`` () = task {
-    fun () -> TaskSeq.empty<string> |> TaskSeq.head |> Task.ignore
+    fun () -> TaskSeq.empty<string> () |> TaskSeq.head |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 }
 
@@ -22,7 +22,7 @@ let ``TaskSeq-head throws on empty sequences - variant`` () = task {
 
 [<Fact>]
 let ``TaskSeq-tryHead returns None on empty sequences`` () = task {
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryHead
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryHead
     nothing |> should be None'
 }
 

src/FSharpy.TaskSeq.Test/TaskSeq.Item.Tests.fs

@@ -10,7 +10,7 @@ open FSharpy
 
 [<Fact>]
 let ``TaskSeq-item throws on empty sequences`` () = task {
-    fun () -> TaskSeq.empty<string> |> TaskSeq.item 0 |> Task.ignore
+    fun () -> TaskSeq.empty<string> () |> TaskSeq.item 0 |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 }
 
@@ -57,22 +57,25 @@ let ``TaskSeq-item always throws with negative values`` () = task {
     fun () -> make50 () |> TaskSeq.item Int32.MinValue |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 
-    fun () -> TaskSeq.empty<string> |> TaskSeq.item -1 |> Task.ignore
+    fun () -> TaskSeq.empty<string> () |> TaskSeq.item -1 |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 
-    fun () -> TaskSeq.empty<string> |> TaskSeq.item -10000 |> Task.ignore
+    fun () ->
+        TaskSeq.empty<string> ()
+        |> TaskSeq.item -10000
+        |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 
     fun () ->
-        TaskSeq.empty<string>
+        TaskSeq.empty<string> ()
         |> TaskSeq.item Int32.MinValue
         |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 }
 
 [<Fact>]
 let ``TaskSeq-tryItem returns None on empty sequences`` () = task {
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryItem 0
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryItem 0
     nothing |> should be None'
 }
 
@@ -119,13 +122,13 @@ let ``TaskSeq-tryItem returns None throws with negative values`` () = task {
     let! nothing = make50 () |> TaskSeq.tryItem Int32.MinValue
     nothing |> should be None'
 
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryItem -1
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryItem -1
     nothing |> should be None'
 
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryItem -10000
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryItem -10000
     nothing |> should be None'
 
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryItem Int32.MinValue
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryItem Int32.MinValue
     nothing |> should be None'
 }
 

src/FSharpy.TaskSeq.Test/TaskSeq.Last.Tests.fs

@@ -10,7 +10,7 @@ open FSharpy
 
 [<Fact>]
 let ``TaskSeq-last throws on empty sequences`` () = task {
-    fun () -> TaskSeq.empty<string> |> TaskSeq.last |> Task.ignore
+    fun () -> TaskSeq.empty<string> () |> TaskSeq.last |> Task.ignore
     |> should throwAsyncExact typeof<ArgumentException>
 }
 
@@ -22,7 +22,7 @@ let ``TaskSeq-last throws on empty sequences - variant`` () = task {
 
 [<Fact>]
 let ``TaskSeq-tryLast returns None on empty sequences`` () = task {
-    let! nothing = TaskSeq.empty<string> |> TaskSeq.tryLast
+    let! nothing = TaskSeq.empty<string> () |> TaskSeq.tryLast
     nothing |> should be None'
 }
 

src/FSharpy.TaskSeq.Test/TaskSeq.Pick.Tests.fs

@@ -18,7 +18,7 @@ open FSharpy
 [<Fact>]
 let ``TaskSeq-pick on an empty sequence raises KeyNotFoundException`` () = task {
     fun () ->
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.pick (fun x -> if x = 12 then Some x else None)
         |> Task.ignore
     |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -36,7 +36,7 @@ let ``TaskSeq-pick on an empty sequence raises KeyNotFoundException - variant``
 [<Fact>]
 let ``TaskSeq-pickAsync on an empty sequence raises KeyNotFoundException`` () = task {
     fun () ->
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.pickAsync (fun x -> task { return if x = 12 then Some x else None })
         |> Task.ignore
     |> should throwAsyncExact typeof<KeyNotFoundException>
@@ -145,7 +145,7 @@ let ``TaskSeq-pickAsync happy path last item of seq`` () = task {
 [<Fact>]
 let ``TaskSeq-tryPick on an empty sequence returns None`` () = task {
     let! nothing =
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.tryPick (fun x -> if x = 12 then Some x else None)
 
     nothing |> should be None'
@@ -154,7 +154,7 @@ let ``TaskSeq-tryPick on an empty sequence returns None`` () = task {
 [<Fact>]
 let ``TaskSeq-tryPickAsync on an empty sequence returns None`` () = task {
     let! nothing =
-        TaskSeq.empty
+        TaskSeq.empty ()
         |> TaskSeq.tryPickAsync (fun x -> task { return if x = 12 then Some x else None })
 
     nothing |> should be None'

src/FSharpy.TaskSeq.Test/TaskSeq.Tests.CE.fs

@@ -105,7 +105,7 @@ let ``CE taskSeq with nested deeply yield! perf test 8521 nested tasks`` () = ta
                                 for i in 0..2 do
                                     yield! createTasks 2
 
-                        yield! TaskSeq.empty
+                        yield! TaskSeq.empty()
     }
 
     let! data = tskSeq |> TaskSeq.toListAsync

src/FSharpy.TaskSeq.Test/TaskSeq.Tests.Other.fs

@@ -9,14 +9,14 @@ open FSharpy
 
 [<Fact>]
 let ``TaskSeq-empty returns an empty sequence`` () = task {
-    let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
+    let! sq = TaskSeq.empty<string> () |> TaskSeq.toSeqCachedAsync
     Seq.isEmpty sq |> should be True
     Seq.length sq |> should equal 0
 }
 
 [<Fact>]
 let ``TaskSeq-isEmpty returns true for empty`` () = task {
-    let! isEmpty = TaskSeq.empty<string> |> TaskSeq.isEmpty
+    let! isEmpty = TaskSeq.empty<string> () |> TaskSeq.isEmpty
     isEmpty |> should be True
 }
 

src/FSharpy.TaskSeq/TaskSeq.fs

@@ -11,7 +11,7 @@ module TaskSeq =
     // Just for convenience
     module Internal = TaskSeqInternal
 
-    let empty<'T> = taskSeq {
+    let empty<'T> () = taskSeq {
         for c: 'T in [] do
             yield c
     }

src/FSharpy.TaskSeq/TaskSeq.fsi

@@ -6,7 +6,7 @@ module TaskSeq =
     open FSharpy.TaskSeqBuilders
 
     /// Initialize an empty taskSeq.
-    val empty<'T> : taskSeq<'T>
+    val empty<'T> : unit -> taskSeq<'T>
 
     /// <summary>
     /// Returns <see cref="true" /> if the task sequence contains no elements, <see cref="false" /> otherwise.