Merge pull request #386 from fsprojects/repo-assist/perf-while-bang-groupby-countby-partition-20260413-6e4499650e6f9190

[Repo Assist] perf: use while! in groupBy, countBy, partition, except, exceptOfSeq

Author: dsyme

release-notes.txt

@@ -5,6 +5,7 @@ Release notes:
     - adds TaskSeq.chooseV, TaskSeq.chooseVAsync, #385
 
 1.0.0
+    - perf: use while! in groupBy, countBy, partition, except, exceptOfSeq to eliminate redundant mutable 'go' variables and initial MoveNextAsync calls
     - adds taskSeqDynamic computation expression and TaskSeqDynamic/TaskSeqDynamicInfo types for dynamic (FSI-compatible) resumable code, fixing issue where taskSeq would raise NotImplementedException in F# Interactive, #246
     - perf: toResizeArrayAsync (and therefore toArrayAsync, toListAsync, toResizeArrayAsync, toIListAsync) uses a direct loop instead of going through iter, avoiding a lambda and DU allocation per call
     - perf: tryItem uses a simpler loop that skips the redundant inner index check on every iteration

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -1484,35 +1484,29 @@ module internal TaskSeqInternal =
 
         taskSeq {
             use e = source.GetAsyncEnumerator CancellationToken.None
-            let mutable go = true
-            let! step = e.MoveNextAsync()
-            go <- step
+            let! hasFirst = e.MoveNextAsync()
 
-            if step then
+            if hasFirst then
                 // only create hashset by the time we actually start iterating;
                 // taskSeq enumerates sequentially, so a plain HashSet suffices — no locking needed.
                 let hashSet = HashSet<_>(HashIdentity.Structural)
 
                 use excl = itemsToExclude.GetAsyncEnumerator CancellationToken.None
-                let! exclStep = excl.MoveNextAsync()
-                let mutable exclGo = exclStep
 
-                while exclGo do
+                while! excl.MoveNextAsync() do
                     hashSet.Add excl.Current |> ignore
-                    let! exclStep = excl.MoveNextAsync()
-                    exclGo <- exclStep
 
-                while go do
+                // if true, it was added, and therefore unique, so we return it
+                // if false, it existed, and therefore a duplicate, and we skip
+                if hashSet.Add e.Current then
+                    yield e.Current
+
+                while! e.MoveNextAsync() do
                     let current = e.Current
 
-                    // if true, it was added, and therefore unique, so we return it
-                    // if false, it existed, and therefore a duplicate, and we skip
                     if hashSet.Add current then
                         yield current
 
-                    let! step = e.MoveNextAsync()
-                    go <- step
-
         }
 
     let exceptOfSeq itemsToExclude (source: TaskSeq<_>) =
@@ -1521,26 +1515,24 @@ module internal TaskSeqInternal =
 
         taskSeq {
             use e = source.GetAsyncEnumerator CancellationToken.None
-            let mutable go = true
-            let! step = e.MoveNextAsync()
-            go <- step
+            let! hasFirst = e.MoveNextAsync()
 
-            if step then
+            if hasFirst then
                 // only create hashset by the time we actually start iterating;
                 // initialize directly from the seq — taskSeq is sequential so no locking needed.
                 let hashSet = HashSet<_>(itemsToExclude, HashIdentity.Structural)
 
-                while go do
+                // if true, it was added, and therefore unique, so we return it
+                // if false, it existed, and therefore a duplicate, and we skip
+                if hashSet.Add e.Current then
+                    yield e.Current
+
+                while! e.MoveNextAsync() do
                     let current = e.Current
 
-                    // if true, it was added, and therefore unique, so we return it
-                    // if false, it existed, and therefore a duplicate, and we skip
                     if hashSet.Add current then
                         yield current
 
-                    let! step = e.MoveNextAsync()
-                    go <- step
-
         }
 
     let distinctUntilChanged (source: TaskSeq<_>) =
@@ -1623,12 +1615,10 @@ module internal TaskSeqInternal =
             use e = source.GetAsyncEnumerator CancellationToken.None
             let groups = Dictionary<'Key, ResizeArray<'T>>(HashIdentity.Structural)
             let order = ResizeArray<'Key>()
-            let! step = e.MoveNextAsync()
-            let mutable go = step
 
             match projector with
             | ProjectorAction proj ->
-                while go do
+                while! e.MoveNextAsync() do
                     let key = proj e.Current
                     let mutable ra = Unchecked.defaultof<_>
 
@@ -1638,11 +1628,9 @@ module internal TaskSeqInternal =
                         order.Add key
 
                     ra.Add e.Current
-                    let! step = e.MoveNextAsync()
-                    go <- step
 
             | AsyncProjectorAction proj ->
-                while go do
+                while! e.MoveNextAsync() do
                     let! key = proj e.Current
                     let mutable ra = Unchecked.defaultof<_>
 
@@ -1652,8 +1640,6 @@ module internal TaskSeqInternal =
                         order.Add key
 
                     ra.Add e.Current
-                    let! step = e.MoveNextAsync()
-                    go <- step
 
             return
                 Array.init order.Count (fun i ->
@@ -1668,33 +1654,27 @@ module internal TaskSeqInternal =
             use e = source.GetAsyncEnumerator CancellationToken.None
             let counts = Dictionary<'Key, int>(HashIdentity.Structural)
             let order = ResizeArray<'Key>()
-            let! step = e.MoveNextAsync()
-            let mutable go = step
 
             match projector with
             | ProjectorAction proj ->
-                while go do
+                while! e.MoveNextAsync() do
                     let key = proj e.Current
                     let mutable count = 0
 
                     if not (counts.TryGetValue(key, &count)) then
                         order.Add key
 
                     counts[key] <- count + 1
-                    let! step = e.MoveNextAsync()
-                    go <- step
 
             | AsyncProjectorAction proj ->
-                while go do
+                while! e.MoveNextAsync() do
                     let! key = proj e.Current
                     let mutable count = 0
 
                     if not (counts.TryGetValue(key, &count)) then
                         order.Add key
 
                     counts[key] <- count + 1
-                    let! step = e.MoveNextAsync()
-                    go <- step
 
             return Array.init order.Count (fun i -> let k = order[i] in k, counts[k])
         }
@@ -1706,29 +1686,22 @@ module internal TaskSeqInternal =
             use e = source.GetAsyncEnumerator CancellationToken.None
             let trueItems = ResizeArray<'T>()
             let falseItems = ResizeArray<'T>()
-            let! step = e.MoveNextAsync()
-            let mutable go = step
 
             match predicate with
             | Predicate pred ->
-                while go do
+                while! e.MoveNextAsync() do
                     let item = e.Current
 
                     if pred item then
                         trueItems.Add item
                     else
                         falseItems.Add item
 
-                    let! step = e.MoveNextAsync()
-                    go <- step
-
             | PredicateAsync pred ->
-                while go do
+                while! e.MoveNextAsync() do
                     let item = e.Current
                     let! result = pred item
                     if result then trueItems.Add item else falseItems.Add item
-                    let! step = e.MoveNextAsync()
-                    go <- step
 
             return trueItems.ToArray(), falseItems.ToArray()
         }