perf: direct loop in toResizeArrayAsync; simplify tryItem loop

toResizeArrayAsync previously went through the iter function with a
SimpleAction DU wrapper, causing a lambda closure allocation and
discriminated-union wrapping on every call. The new direct loop
eliminates these allocations and removes an extra layer of indirection.
This benefits toArrayAsync, toListAsync, toResizeArrayAsync, and
toIListAsync which all route through toResizeArrayAsync.

tryItem previously used a while-loop with condition idx <= index and an
inner if idx = index check on every iteration. The refactored version
advances with idx < index and captures the current element after the
loop, removing the redundant inner comparison from the hot path.

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

Author: github-actions[bot]

release-notes.txt

@@ -3,6 +3,8 @@ Release notes:
 
 1.0.0
     - 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
     - perf: TaskSeq.chunkBy and chunkByAsync reuse the ResizeArray buffer between chunks, reducing allocations on sequences with many chunk boundaries
     - fixes: TaskSeq.insertAt, insertManyAt, removeAt, removeManyAt, updateAt now raise ArgumentNullException (not NullReferenceException) when given a null source; insertManyAt also validates the values argument
     - refactor: simplify lengthBy and lengthBeforeMax to use while! and remove the redundant mutable 'go' and initial MoveNextAsync

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -532,12 +532,16 @@ module internal TaskSeqInternal =
                 yield result
         }
 
-    let toResizeArrayAsync source =
+    let toResizeArrayAsync (source: TaskSeq<'T>) =
         checkNonNull (nameof source) source
 
         task {
-            let res = ResizeArray()
-            do! source |> iter (SimpleAction(fun item -> res.Add item))
+            let res = ResizeArray<'T>()
+            use e = source.GetAsyncEnumerator CancellationToken.None
+
+            while! e.MoveNextAsync() do
+                res.Add e.Current
+
             return res
         }
 
@@ -915,14 +919,14 @@ module internal TaskSeqInternal =
                 let! step = e.MoveNextAsync()
                 go <- step
 
-                while go && idx <= index do
-                    if idx = index then
-                        foundItem <- Some e.Current
-                        go <- false
-                    else
-                        let! step = e.MoveNextAsync()
-                        go <- step
-                        idx <- idx + 1
+                // advance past the first `index` elements, then capture the current element
+                while go && idx < index do
+                    let! step = e.MoveNextAsync()
+                    go <- step
+                    idx <- idx + 1
+
+                if go then
+                    foundItem <- Some e.Current
 
                 return foundItem
         }