Implement TaskSeq.forall and forallAsync; add Task/ValueTask boolean operator overloads

Author: abelbraaksma

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -360,6 +360,9 @@ type TaskSeq private () =
     static member except itemsToExclude source = Internal.except itemsToExclude source
     static member exceptOfSeq itemsToExclude source = Internal.exceptOfSeq itemsToExclude source
 
+    static member forall predicate source = Internal.forall (Predicate predicate) source
+    static member forallAsync predicate source = Internal.forall (PredicateAsync predicate) source
+
     static member exists predicate source =
         Internal.tryFind (Predicate predicate) source
         |> Task.map Option.isSome

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -690,18 +690,54 @@ module internal TaskSeqInternal =
 
         taskSeq {
             match predicate with
-            | Predicate predicate ->
+            | Predicate syncPredicate ->
                 for item in source do
-                    if predicate item then
+                    if syncPredicate item then
                         yield item
 
-            | PredicateAsync predicate ->
+            | PredicateAsync asyncPredicate ->
                 for item in source do
-                    match! predicate item with
+                    match! asyncPredicate item with
                     | true -> yield item
                     | false -> ()
         }
 
+    let forall predicate (source: TaskSeq<_>) =
+        checkNonNull (nameof source) source
+
+        match predicate with
+        | Predicate syncPredicate -> task {
+            use e = source.GetAsyncEnumerator CancellationToken.None
+            let mutable state = true
+            let! cont = e.MoveNextAsync()
+            let mutable hasMore = cont
+
+            while state && hasMore do
+                state <- syncPredicate e.Current
+
+                if state then
+                    let! cont = e.MoveNextAsync()
+                    hasMore <- cont
+
+            return state
+          }
+
+        | PredicateAsync asyncPredicate -> task {
+            use e = source.GetAsyncEnumerator CancellationToken.None
+            let mutable state = true
+            let! cont = e.MoveNextAsync()
+            let mutable hasMore = cont
+
+            while state && hasMore do
+                let! pred = asyncPredicate e.Current
+                state <- pred
+
+                if state then
+                    let! cont = e.MoveNextAsync()
+                    hasMore <- cont
+
+            return state
+          }
 
     let skipOrTake skipOrTake count (source: TaskSeq<_>) =
         checkNonNull (nameof source) source

src/FSharp.Control.TaskSeq/Utils.fs

@@ -42,6 +42,8 @@ module ValueTask =
 
 
 module Task =
+    let False = Task.FromResult false
+    let True = Task.FromResult true
     let inline fromResult (value: 'U) : Task<'U> = Task.FromResult value
     let inline ofAsync (async: Async<'T>) = task { return! async }
     let inline ofTask (task': Task) = task { do! task' }

src/FSharp.Control.TaskSeq/Utils.fsi

@@ -49,6 +49,11 @@ module ValueTask =
     val inline ignore: vtask: ValueTask<'T> -> ValueTask
 
 module Task =
+    /// A successfully completed Task of boolean that has the value false.
+    val False: Task<bool>
+
+    /// A successfully completed Task of boolean that has the value true.
+    val True: Task<bool>
 
     /// Convert an Async<'T> into a Task<'T>
     val inline ofAsync: async: Async<'T> -> Task<'T>