[Repo Assist] perf: optimize TaskSeq.replicate with direct object-expression implementation

release-notes.txt

@@ -3,6 +3,7 @@ Release notes:
 
 0.6.0
     - fixes: async { for item in taskSeq do ... } no longer wraps exceptions in AggregateException, #129
+    - performance: TaskSeq.replicate now uses a direct object-expression implementation, avoiding the taskSeq CE state machine and range IEnumerable/IEnumerator allocation
     - adds TaskSeq.compareWith and TaskSeq.compareWithAsync
     - adds TaskSeq.scan and TaskSeq.scanAsync, #289
     - adds TaskSeq.pairwise, #289

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -147,9 +147,22 @@ module internal TaskSeqInternal =
     let replicate count value =
         raiseCannotBeNegative (nameof count) count
 
-        taskSeq {
-            for _ in 1..count do
-                yield value
+        // Direct object-expression implementation: avoids the taskSeq CE state machine,
+        // the 1..count range IEnumerable, and its IEnumerator — all of which are unnecessary
+        // for this simple, always-synchronous sequence. MoveNextAsync always completes
+        // synchronously, which is the optimal fast path for ValueTask consumers.
+        { new IAsyncEnumerable<'T> with
+            member _.GetAsyncEnumerator _ =
+                let mutable i = 0
+
+                { new IAsyncEnumerator<'T> with
+                    member _.MoveNextAsync() =
+                        i <- i + 1
+                        ValueTask<bool>(i <= count)
+
+                    member _.Current = value
+                    member _.DisposeAsync() = ValueTask.CompletedTask
+                }
         }
 
     /// Returns length unconditionally, or based on a predicate