Use a struct DU for differentiating between exclusive/inclusive while, and remove a few branching tests

Author: abelbraaksma

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -253,10 +253,10 @@ module TaskSeq =
     let chooseAsync chooser source = Internal.choose (TryPickAsync chooser) source
     let filter predicate source = Internal.filter (Predicate predicate) source
     let filterAsync predicate source = Internal.filter (PredicateAsync predicate) source
-    let takeWhile predicate source = Internal.takeWhile (*inclusive:*)false (Predicate predicate) source
-    let takeWhileAsync predicate source = Internal.takeWhile false (PredicateAsync predicate) source
-    let takeWhileInclusive predicate source = Internal.takeWhile true (Predicate predicate) source
-    let takeWhileInclusiveAsync predicate source = Internal.takeWhile true (PredicateAsync predicate) source
+    let takeWhile predicate source = Internal.takeWhile Exclusive (Predicate predicate) source
+    let takeWhileAsync predicate source = Internal.takeWhile Exclusive (PredicateAsync predicate) source
+    let takeWhileInclusive predicate source = Internal.takeWhile Inclusive (Predicate predicate) source
+    let takeWhileInclusiveAsync predicate source = Internal.takeWhile Inclusive (PredicateAsync predicate) source
     let tryPick chooser source = Internal.tryPick (TryPick chooser) source
     let tryPickAsync chooser source = Internal.tryPick (TryPickAsync chooser) source
     let tryFind predicate source = Internal.tryFind (Predicate predicate) source

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -11,6 +11,11 @@ type internal AsyncEnumStatus =
     | WithCurrent
     | AfterAll
 
+[<Struct>]
+type internal WhileKind =
+    | Inclusive
+    | Exclusive
+
 [<Struct>]
 type internal Action<'T, 'U, 'TaskU when 'TaskU :> Task<'U>> =
     | CountableAction of countable_action: (int -> 'T -> 'U)
@@ -532,28 +537,52 @@ module internal TaskSeqInternal =
                 | false -> ()
     }
 
-    let takeWhile inclusive predicate (source: taskSeq<_>) = taskSeq {
+    let takeWhile whileKind predicate (source: taskSeq<_>) = taskSeq {
         use e = source.GetAsyncEnumerator(CancellationToken())
         let! step = e.MoveNextAsync()
         let mutable more = step
 
-        match predicate with
-        | Predicate predicate ->
+        match whileKind, predicate with
+        | Exclusive, Predicate predicate ->
             while more do
                 let value = e.Current
                 more <- predicate value
-                if more || inclusive then
+
+                if more then
                     yield value
+                    let! ok = e.MoveNextAsync()
+                    more <- ok
+
+        | Inclusive, Predicate predicate ->
+            while more do
+                let value = e.Current
+                more <- predicate value
+
+                yield value
+
                 if more then
                     let! ok = e.MoveNextAsync()
                     more <- ok
-        | PredicateAsync predicate ->
+
+        | Exclusive, PredicateAsync predicate ->
             while more do
                 let value = e.Current
                 let! passed = predicate value
                 more <- passed
-                if more || inclusive then
+
+                if more then
                     yield value
+                    let! ok = e.MoveNextAsync()
+                    more <- ok
+
+        | Inclusive, PredicateAsync predicate ->
+            while more do
+                let value = e.Current
+                let! passed = predicate value
+                more <- passed
+
+                yield value
+
                 if more then
                     let! ok = e.MoveNextAsync()
                     more <- ok