refactor: simplify lengthBy and lengthBeforeMax using while!

Replace the pattern of:
  - one unconditional MoveNextAsync call before the loop
  - a mutable 'go' flag
  - manual go/step tracking

...with the simpler 'while! e.MoveNextAsync() do' form.

For lengthBy (all three predicate variants), the new implementation is cleaner
and reads more naturally: iterate over elements, count those that match.

For lengthBeforeMax, the new implementation advances the enumerator inside the
loop body and guards with 'go && i < max', eliminating the pre-loop advance.
A beneficial side effect: the old implementation had a read-ahead of 1 (an
extra MoveNextAsync call before the loop), which meant lengthOrMax 5 on a
10-element source would evaluate 6 elements instead of 5, and lengthOrMax 0
would still evaluate the first element.  The new implementation has no
read-ahead, so lengthOrMax N evaluates exactly N elements as expected.

Tests updated to reflect the improved (no read-ahead) behaviour, replacing
the N+1 and 1 assertions with the correct N and 0.

All 5013 existing tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

release-notes.txt

@@ -2,6 +2,7 @@
 Release notes:
 
 1.0.0
+    - refactor: simplify lengthBy and lengthBeforeMax to use while! and remove the redundant mutable 'go' and initial MoveNextAsync
     - adds TaskSeq.distinctUntilChangedWith and TaskSeq.distinctUntilChangedWithAsync, #345
     - adds TaskSeq.withCancellation, #167
     - adds TaskSeq.replicateInfinite, replicateInfiniteAsync, replicateUntilNoneAsync, #345

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

@@ -300,8 +300,7 @@ module SideEffects =
 
     [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
     let ``TaskSeq-lengthOrMax returns max and stops evaluation when sequence exceeds max`` variant = task {
-        // source has 10 items; max=5 → should stop early
-        // NOTE: the implementation reads one element ahead (N+1 total MoveNextAsync calls for result N)
+        // source has 10 items; max=5 → should stop early after exactly 5 elements
         let mutable evaluated = 0
 
         let ts = taskSeq {
@@ -312,14 +311,12 @@ module SideEffects =
 
         let! len = ts |> TaskSeq.lengthOrMax 5
         len |> should equal 5
-        // exactly max+1 elements are pulled from the source due to read-ahead
-        evaluated |> should equal 6
+        // exactly max elements are pulled from the source
+        evaluated |> should equal 5
     }
 
     [<Fact>]
-    let ``TaskSeq-lengthOrMax stops evaluating source after reaching max - read-ahead characteristic`` () = task {
-        // NOTE: the implementation calls MoveNextAsync once before the while loop,
-        // then once more per iteration. For max=N and a longer source, this means N+1 calls total.
+    let ``TaskSeq-lengthOrMax stops evaluating source after reaching max`` () = task {
         let mutable sideEffects = 0
 
         let ts = taskSeq {
@@ -330,14 +327,12 @@ module SideEffects =
 
         let! len = ts |> TaskSeq.lengthOrMax 7
         len |> should equal 7
-        // max+1 elements are evaluated due to the read-ahead implementation pattern
-        sideEffects |> should equal 8
+        // exactly max elements are evaluated
+        sideEffects |> should equal 7
     }
 
     [<Fact>]
-    let ``TaskSeq-lengthOrMax with max=0 still evaluates the first element due to read-ahead`` () = task {
-        // The implementation unconditionally calls MoveNextAsync once before entering
-        // the while loop, so even max=0 evaluates the first element of the source.
+    let ``TaskSeq-lengthOrMax with max=0 evaluates zero elements`` () = task {
         let mutable sideEffects = 0
 
         let ts = taskSeq {
@@ -349,6 +344,6 @@ module SideEffects =
 
         let! len = ts |> TaskSeq.lengthOrMax 0
         len |> should equal 0
-        // one element was evaluated despite max=0
-        sideEffects |> should equal 1
+        // no elements evaluated when max=0
+        sideEffects |> should equal 0
     }

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -179,37 +179,25 @@ module internal TaskSeqInternal =
         checkNonNull (nameof source) source
 
         task {
-
             use e = source.GetAsyncEnumerator CancellationToken.None
-            let mutable go = true
             let mutable i = 0
-            let! step = e.MoveNextAsync()
-            go <- step
 
             match predicate with
             | None ->
-                while go do
-                    let! step = e.MoveNextAsync()
-                    i <- i + 1 // update before moving: we are counting, not indexing
-                    go <- step
+                while! e.MoveNextAsync() do
+                    i <- i + 1
 
             | Some(Predicate predicate) ->
-                while go do
+                while! e.MoveNextAsync() do
                     if predicate e.Current then
                         i <- i + 1
 
-                    let! step = e.MoveNextAsync()
-                    go <- step
-
             | Some(PredicateAsync predicate) ->
-                while go do
+                while! e.MoveNextAsync() do
                     match! predicate e.Current with
                     | true -> i <- i + 1
                     | false -> ()
 
-                    let! step = e.MoveNextAsync()
-                    go <- step
-
             return i
         }
 
@@ -219,15 +207,13 @@ module internal TaskSeqInternal =
 
         task {
             use e = source.GetAsyncEnumerator CancellationToken.None
-            let mutable go = true
             let mutable i = 0
-            let! step = e.MoveNextAsync()
-            go <- step
+            let mutable go = true
 
             while go && i < max do
-                i <- i + 1 // update before moving: we are counting, not indexing
-                let! step = e.MoveNextAsync()
-                go <- step
+                let! hasMore = e.MoveNextAsync()
+
+                if hasMore then i <- i + 1 else go <- false
 
             return i
         }