Merge branch 'main' into repo-assist/perf-take-skip-enumerators-b793dd82cef306c6

Author: dsyme

.github/aw/actions-lock.json

@@ -10,10 +10,15 @@
       "version": "v8",
       "sha": "ed597411d8f924073f98dfc5c65a23a2325f34cd"
     },
-    "github/gh-aw/actions/[email protected]": {
+    "github/gh-aw-actions/[email protected]": {
+      "repo": "github/gh-aw-actions/setup",
+      "version": "v0.61.1",
+      "sha": "be0029bbbaeef8c6bea6825f31d9593219b2dc28"
+    },
+    "github/gh-aw/actions/[email protected]": {
       "repo": "github/gh-aw/actions/setup",
-      "version": "v0.56.2",
-      "sha": "f1073c5498ee46fec1530555a7c953445417c69b"
+      "version": "v0.61.2",
+      "sha": "d6f6273a03402cd530be35455a7823494b846d66"
     }
   }
 }

.github/workflows/repo-assist.lock.yml

@@ -1,6 +1,6 @@
 ---
 description: |
-  A friendly repository assistant that runs 4 times a day to support contributors and maintainers.
+  A friendly repository assistant that runs 2 times a day to support contributors and maintainers.
   Can also be triggered on-demand via '/repo-assist <instructions>' to perform specific tasks.
   - Labels and triages open issues
   - Comments helpfully on open issues to unblock contributors and onboard newcomers
@@ -33,6 +33,19 @@ network:
   - rust
   - java
 
+checkout:
+  fetch: ["*"]     # fetch all remote branches to allow working on PR branches
+  fetch-depth: 0   # fetch full history
+
+tools:
+  web-fetch:
+  github:
+    toolsets: [all]
+    min-integrity: none # This workflow is allowed to examine and comment on any issues or PRs
+    repos: all
+  bash: true
+  repo-memory: true
+
 safe-outputs:
   add-comment:
     max: 10
@@ -65,13 +78,6 @@ safe-outputs:
     max: 5
     target: "*"
 
-tools:
-  web-fetch:
-  github:
-    toolsets: [all]
-  bash: true
-  repo-memory: true
-
 steps:
   - name: Fetch repo data for task weighting
     env:
@@ -165,7 +171,7 @@ steps:
           json.dump(result, f, indent=2)
       EOF
 
-source: githubnext/agentics/workflows/repo-assist.md@346204513ecfa08b81566450d7d599556807389f
+source: githubnext/agentics/workflows/repo-assist.md@d1d884596e62351dd652ae78465885dd32f0dd7d
 ---
 
 # Repo Assist

.github/workflows/repo-assist.md

@@ -1,3 +1,22 @@
+### 4.11.0
+
+* Design parity with FSharp.Control.TaskSeq (#277, batch 2):
+  * Added `AsyncSeq.tryTail` — returns `None` if the sequence is empty; otherwise returns `Some` of the tail. Safe counterpart to `tail`. Mirrors `TaskSeq.tryTail`.
+  * Added `AsyncSeq.where` / `AsyncSeq.whereAsync` — aliases for `filter` / `filterAsync`, mirroring the naming convention in `TaskSeq` and F# 8 collection expressions.
+  * Added `AsyncSeq.lengthBy` / `AsyncSeq.lengthByAsync` — counts elements satisfying a predicate. Mirrors `TaskSeq.lengthBy` / `TaskSeq.lengthByAsync`.
+  * Added `AsyncSeq.compareWith` / `AsyncSeq.compareWithAsync` — lexicographically compares two async sequences using a comparison function. Mirrors `TaskSeq.compareWith` / `TaskSeq.compareWithAsync`.
+  * Added `AsyncSeq.takeWhileInclusiveAsync` — async variant of the existing `takeWhileInclusive`. Mirrors `TaskSeq.takeWhileInclusiveAsync`.
+  * Added `AsyncSeq.skipWhileInclusive` / `AsyncSeq.skipWhileInclusiveAsync` — skips elements while predicate holds and also skips the first non-matching boundary element. Mirrors `TaskSeq.skipWhileInclusive` / `TaskSeq.skipWhileInclusiveAsync`.
+  * Added `AsyncSeq.appendSeq` — appends a synchronous `seq<'T>` after an async sequence. Mirrors `TaskSeq.appendSeq`.
+  * Added `AsyncSeq.prependSeq` — prepends a synchronous `seq<'T>` before an async sequence. Mirrors `TaskSeq.prependSeq`.
+  * Added `AsyncSeq.delay` — defers sequence creation to enumeration time by calling a factory function each time `GetAsyncEnumerator` is called. Mirrors `TaskSeq.delay`.
+  * Added `AsyncSeq.collectAsync` — like `collect` but the mapping function is asynchronous (`'T -> Async<AsyncSeq<'U>>`). Mirrors `TaskSeq.collectAsync`.
+  * Added `AsyncSeq.partition` / `AsyncSeq.partitionAsync` — splits a sequence into two arrays using a (optionally async) predicate; the first array contains matching elements, the second non-matching. Mirrors `TaskSeq.partition` / `TaskSeq.partitionAsync`.
+
+### 4.10.0
+
+* Added `AsyncSeq.withCancellation` — returns a new `AsyncSeq` that passes the given `CancellationToken` to `GetAsyncEnumerator`, overriding whatever token would otherwise be supplied. Mirrors `TaskSeq.withCancellation` and is useful when consuming sequences from libraries (e.g. Entity Framework) that accept a cancellation token through `GetAsyncEnumerator`. Part of ongoing design-parity work with FSharp.Control.TaskSeq (see #277).
+
 ### 4.9.0
 
 * Performance: `filterAsync` — replaced `asyncSeq`-builder implementation with a direct optimised enumerator, reducing allocation and generator overhead.

RELEASE_NOTES.md

@@ -492,8 +492,8 @@ module AsyncSeq =
                 | Some enum -> dispose enum
                 | None -> () }) :> AsyncSeq<'T>
 
-  let inline delay (f: unit -> AsyncSeq<'T>) : AsyncSeq<'T> =
-    AsyncGenerator.delay f
+  let delay (f: unit -> AsyncSeq<'T>) : AsyncSeq<'T> =
+    AsyncSeqImpl(fun () -> (f()).GetEnumerator()) :> AsyncSeq<'T>
 
   let bindAsync (f:'T -> AsyncSeq<'U>) (inp:Async<'T>) : AsyncSeq<'U> =
     AsyncSeqImpl(fun () ->
@@ -703,6 +703,9 @@ module AsyncSeq =
   let collect (f: 'T -> AsyncSeq<'U>) (inp: AsyncSeq<'T>) : AsyncSeq<'U> =
     AsyncSeqImpl(fun () -> new OptimizedCollectEnumerator<'T, 'U>(f, inp) :> IAsyncSeqEnumerator<'U>) :> AsyncSeq<'U>
 
+  let collectAsync (mapping: 'T -> Async<AsyncSeq<'U>>) (source: AsyncSeq<'T>) : AsyncSeq<'U> =
+    collect (fun x -> bindAsync id (mapping x)) source
+
 //  let collect (f: 'T -> AsyncSeq<'U>) (inp: AsyncSeq<'T>) : AsyncSeq<'U> =
 //    AsyncGenerator.collect f inp
 
@@ -787,6 +790,12 @@ module AsyncSeq =
                                 dispose e
                             | _ -> () }) :> AsyncSeq<'T>
 
+  let appendSeq (seq2: seq<'T>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    append source (ofSeq seq2)
+
+  let prependSeq (seq1: seq<'T>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    append (ofSeq seq1) source
+
   // Optimized iterAsync implementation to reduce allocations
   type internal OptimizedIterAsyncEnumerator<'T>(enumerator: IAsyncSeqEnumerator<'T>, f: 'T -> Async<unit>) =
     let mutable disposed = false
@@ -1361,6 +1370,33 @@ module AsyncSeq =
   let forallAsync f (source : AsyncSeq<'T>) =
     source |> existsAsync (fun v -> async { let! b = f v in return not b }) |> Async.map not
 
+  let compareWithAsync (comparer: 'T -> 'T -> Async<int>) (source1: AsyncSeq<'T>) (source2: AsyncSeq<'T>) : Async<int> = async {
+    use ie1 = source1.GetEnumerator()
+    use ie2 = source2.GetEnumerator()
+    let! m1 = ie1.MoveNext()
+    let! m2 = ie2.MoveNext()
+    let b1 = ref m1
+    let b2 = ref m2
+    let result = ref 0
+    let isDone = ref false
+    while not isDone.Value do
+        match b1.Value, b2.Value with
+        | None, None -> isDone := true
+        | None, Some _ -> result := -1; isDone := true
+        | Some _, None -> result := 1; isDone := true
+        | Some v1, Some v2 ->
+            let! c = comparer v1 v2
+            if c <> 0 then result := c; isDone := true
+            else
+                let! n1 = ie1.MoveNext()
+                let! n2 = ie2.MoveNext()
+                b1 := n1
+                b2 := n2
+    return result.Value }
+
+  let compareWith (comparer: 'T -> 'T -> int) (source1: AsyncSeq<'T>) (source2: AsyncSeq<'T>) : Async<int> =
+    compareWithAsync (fun a b -> comparer a b |> async.Return) source1 source2
+
   let foldAsync f (state:'State) (source : AsyncSeq<'T>) =
     match source with
     | :? AsyncSeqOp<'T> as source -> source.FoldAsync f state
@@ -1418,6 +1454,12 @@ module AsyncSeq =
   let length (source : AsyncSeq<'T>) =
     fold (fun st _ -> st + 1L) 0L source
 
+  let lengthByAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : Async<int64> =
+    foldAsync (fun acc x -> async { let! ok = predicate x in return if ok then acc + 1L else acc }) 0L source
+
+  let lengthBy (predicate: 'T -> bool) (source: AsyncSeq<'T>) : Async<int64> =
+    lengthByAsync (predicate >> async.Return) source
+
   let inline sum (source : AsyncSeq<'T>) : Async<'T> =
     (LanguagePrimitives.GenericZero, source) ||> fold (+)
 
@@ -1548,6 +1590,12 @@ module AsyncSeq =
   let filter f (source : AsyncSeq<'T>) =
     filterAsync (f >> async.Return) source
 
+  let where (predicate: 'T -> bool) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    filter predicate source
+
+  let whereAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    filterAsync predicate source
+
   let except (excluded : seq<'T>) (source : AsyncSeq<'T>) : AsyncSeq<'T> =
     let s = System.Collections.Generic.HashSet(excluded)
     source |> filter (fun x -> not (s.Contains(x)))
@@ -1898,6 +1946,24 @@ module AsyncSeq =
           interface System.IDisposable with
             member _.Dispose() = en.Dispose() }) :> AsyncSeq<'a>
 
+  let takeWhileInclusiveAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    AsyncSeqImpl(fun () ->
+        let en = source.GetEnumerator()
+        let fin = ref false
+        { new IAsyncSeqEnumerator<'T> with
+            member _.MoveNext() = async {
+                if !fin then return None
+                else
+                    let! next = en.MoveNext()
+                    match next with
+                    | None -> return None
+                    | Some a ->
+                        let! ok = predicate a
+                        if ok then return Some a
+                        else fin := true; return Some a }
+          interface System.IDisposable with
+            member _.Dispose() = en.Dispose() }) :> AsyncSeq<'T>
+
   let skipWhileAsync p (source : AsyncSeq<'T>) : AsyncSeq<_> = asyncSeq {
       use ie = source.GetEnumerator()
       let! move = ie.MoveNext()
@@ -1915,6 +1981,27 @@ module AsyncSeq =
           let! moven = ie.MoveNext()
           b := moven }
 
+  let skipWhileInclusiveAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
+      use ie = source.GetEnumerator()
+      let! move = ie.MoveNext()
+      let b = ref move
+      let doneSkipping = ref false
+      while b.Value.IsSome do
+          let v = b.Value.Value
+          if doneSkipping.Value then
+              yield v
+              let! moven = ie.MoveNext()
+              b := moven
+          else
+              let! test = predicate v
+              if not test then
+                  doneSkipping := true  // skip this boundary element; do not yield it
+              let! moven = ie.MoveNext()
+              b := moven }
+
+  let skipWhileInclusive (predicate: 'T -> bool) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    skipWhileInclusiveAsync (predicate >> async.Return) source
+
   #if !FABLE_COMPILER
   let skipUntilSignal (signal:Async<unit>) (source:AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
       use ie = source.GetEnumerator()
@@ -1959,6 +2046,25 @@ module AsyncSeq =
 
   let tail (source : AsyncSeq<'T>) : AsyncSeq<'T> = skip 1 source
 
+  let tryTail (source: AsyncSeq<'T>) : Async<AsyncSeq<'T> option> = async {
+    let ie = source.GetEnumerator()
+    let! first = ie.MoveNext()
+    match first with
+    | None ->
+        ie.Dispose()
+        return None
+    | Some _ ->
+        return Some (asyncSeq {
+            try
+                let! next = ie.MoveNext()
+                let b = ref next
+                while b.Value.IsSome do
+                    yield b.Value.Value
+                    let! moven = ie.MoveNext()
+                    b := moven
+            finally
+                ie.Dispose() }) }
+
   /// Splits an async sequence at the given index, returning the first `count` elements as an array
   /// and the remaining elements as a new AsyncSeq. The source is enumerated once.
   let splitAt (count: int) (source: AsyncSeq<'T>) : Async<'T array * AsyncSeq<'T>> = async {
@@ -2005,6 +2111,17 @@ module AsyncSeq =
   let toArraySynchronously (source:AsyncSeq<'T>) = toArrayAsync source |> Async.RunSynchronously
   #endif
 
+  let partitionAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : Async<'T[] * 'T[]> = async {
+    let trues = ResizeArray<'T>()
+    let falses = ResizeArray<'T>()
+    do! source |> iterAsync (fun x -> async {
+        let! ok = predicate x
+        (if ok then trues else falses).Add(x) })
+    return trues.ToArray(), falses.ToArray() }
+
+  let partition (predicate: 'T -> bool) (source: AsyncSeq<'T>) : Async<'T[] * 'T[]> =
+    partitionAsync (predicate >> async.Return) source
+
   let concatSeq (source:AsyncSeq<#seq<'T>>) : AsyncSeq<'T> = asyncSeq {
       use ie = source.GetEnumerator()
       let! move = ie.MoveNext()
@@ -2551,6 +2668,13 @@ module AsyncSeq =
             (emptyAsync fillChannelTask)
       }
 
+  /// Returns a new AsyncSeq that passes the given CancellationToken to GetAsyncEnumerator,
+  /// overriding whatever token would otherwise be used. Useful when consuming sequences from
+  /// libraries (such as Entity Framework) that accept a CancellationToken through GetAsyncEnumerator.
+  let withCancellation (cancellationToken: CancellationToken) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    { new IAsyncEnumerable<'T> with
+        member _.GetAsyncEnumerator(_ct) = source.GetAsyncEnumerator(cancellationToken) }
+
   #endif