Merge branch 'main' into repo-assist/eng-update-fsdocs-22alpha3-20260403-596ea5adde75c6f0

Author: dsyme

.config/dotnet-tools.json

@@ -10,7 +10,7 @@
       "rollForward": false
     },
     "fable": {
-      "version": "4.25.0",
+      "version": "5.0.0-rc.7",
       "commands": [
         "fable"
       ],

.github/aw/actions-lock.json

@@ -5,20 +5,20 @@
       "version": "v6.0.2",
       "sha": "de0fac2e4500dabe0009e67214ff5f5447ce83dd"
     },
-    "actions/github-script@v8": {
+    "actions/github-script@v9.0.0": {
       "repo": "actions/github-script",
-      "version": "v8",
-      "sha": "ed597411d8f924073f98dfc5c65a23a2325f34cd"
+      "version": "v9.0.0",
+      "sha": "d746ffe35508b1917358783b479e04febd2b8f71"
     },
-    "github/gh-aw-actions/setup@v0.65.6": {
+    "github/gh-aw-actions/setup@v0.68.1": {
       "repo": "github/gh-aw-actions/setup",
-      "version": "v0.65.6",
-      "sha": "31130b20a8fd3ef263acbe2091267c0aace07e09"
+      "version": "v0.68.1",
+      "sha": "2fe53acc038ba01c3bbdc767d4b25df31ca5bdfc"
     },
-    "github/gh-aw/actions/setup@v0.65.6": {
+    "github/gh-aw/actions/setup@v0.68.1": {
       "repo": "github/gh-aw/actions/setup",
-      "version": "v0.65.6",
-      "sha": "296262211b372a13b451ca9400369ac152db75d6"
+      "version": "v0.68.1",
+      "sha": "5a06d310cf45161bde77d070065a1e1489fc411c"
     }
   }
 }

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

@@ -176,7 +176,7 @@ steps:
           json.dump(result, f, indent=2)
       EOF
 
-source: githubnext/agentics/workflows/repo-assist.md@4ea8c81959909f40373e2a5c2b7fdb54ea19e0a5
+source: githubnext/agentics/workflows/repo-assist.md@97143ac59cb3a13ef2a77581f929f06719c7402a
 ---
 
 # Repo Assist

.github/workflows/repo-assist.md

@@ -1,5 +1,16 @@
+### 4.13.0
+
+* CI: Upgrade Fable from 4.25.0 to 5.0.0-rc.7 and .NET SDK from 8.0.19 to 10.0.100 to fix a CI hang where the Fable build step ran for 6+ hours with .NET 10. Fable 5 + .NET 10 compiles in ~20 seconds.
+* CI: Conditionally disable SourceLink for Fable builds to fix a compilation error where AssemblyInfo.fs was being embedded by SourceLink and passed to the Fable compiler.
+* Tests: Update 4 Fable tests that used `rejects.toThrow()` to use `Async.Catch` with a `Choice2Of2` pattern match instead, since Fable 5's `failwith` throws a custom `Exception` type that is not a JavaScript `Error` instance.
+* Added `AsyncSeq.ofList` — creates an async sequence from an F# list with an optimised direct-enumerator implementation (avoids `IEnumerator<T>` boxing).
+* Added `AsyncSeq.ofArray` — creates an async sequence from an array with an optimised index-based enumerator (avoids `IEnumerator<T>` boxing).
+* Added `AsyncSeq.cycle` — infinitely cycles through all elements of a source async sequence; returns empty if the source is empty.
+
 ### 4.12.0
 
+* Tests: Added tests for `mapiAsync`, `tryPickAsync`, `pickAsync`, and `groupByAsync` — these four async functions previously had no test coverage.
+* Performance: Modernised `singleton`, `collectSeq`, `takeWhileInclusive`, and `takeWhileInclusiveAsync` to use `mutable` local variables instead of `ref` cells (`!`/`:=` operators). Eliminates heap-allocated `Ref<T>` objects in these enumerators, reducing GC pressure consistent with the improvements in 4.11.0.
 * Added `AsyncSeq.tryFindBack` — returns the last element for which the predicate returns true, or `None` if no match. Mirrors `Array.tryFindBack` / `List.tryFindBack`.
 * Added `AsyncSeq.tryFindBackAsync` — async-predicate variant of `tryFindBack`.
 * Added `AsyncSeq.findBack` — returns the last element for which the predicate returns true; raises `KeyNotFoundException` if no match. Mirrors `Array.findBack` / `List.findBack`.

RELEASE_NOTES.md

@@ -450,11 +450,11 @@ module AsyncSeq =
 
   let singleton (v:'T) : AsyncSeq<'T> =
     AsyncSeqImpl(fun () ->
-        let state = ref 0
+        let mutable state = 0
         { new IAsyncSeqEnumerator<'T> with
             member _.MoveNext() = async {
-                let res = state.Value = 0
-                incr state
+                let res = state = 0
+                state <- state + 1
                 return (if res then Some v else None) }
           interface System.IDisposable with
             member _.Dispose() = () }) :> AsyncSeq<'T>
@@ -719,20 +719,20 @@ module AsyncSeq =
   // Like collect, but the input is a sequence, where no bind is required on each step of the enumeration
   let collectSeq (f: 'T -> AsyncSeq<'U>) (inp: seq<'T>) : AsyncSeq<'U> =
         AsyncSeqImpl(fun () ->
-            let state = ref (CollectSeqState.NotStarted inp)
+            let mutable state = CollectSeqState.NotStarted inp
             { new IAsyncSeqEnumerator<'U> with
                         member x.MoveNext() =
-                            async { match !state with
+                            async { match state with
                                     | CollectSeqState.NotStarted inp ->
                                         return!
                                            (let e1 = inp.GetEnumerator()
-                                            state := CollectSeqState.HaveInputEnumerator e1
+                                            state <- CollectSeqState.HaveInputEnumerator e1
                                             x.MoveNext())
                                     | CollectSeqState.HaveInputEnumerator e1 ->
                                         return!
                                           (if e1.MoveNext()  then
                                                let e2 = (f e1.Current).GetEnumerator()
-                                               state := CollectSeqState.HaveInnerEnumerator (e1, e2)
+                                               state <- CollectSeqState.HaveInnerEnumerator (e1, e2)
                                            else
                                                x.Dispose()
                                            x.MoveNext())
@@ -741,19 +741,19 @@ module AsyncSeq =
                                         match res2 with
                                         | None ->
                                             return!
-                                              (state := CollectSeqState.HaveInputEnumerator e1
+                                              (state <- CollectSeqState.HaveInputEnumerator e1
                                                dispose e2
                                                x.MoveNext())
                                         | Some _ ->
                                             return res2
                                     | _ -> return None}
                         member x.Dispose() =
-                            match !state with
+                            match state with
                             | CollectSeqState.HaveInputEnumerator e1 ->
-                                state := CollectSeqState.Finished
+                                state <- CollectSeqState.Finished
                                 dispose e1
                             | CollectSeqState.HaveInnerEnumerator (e1, e2) ->
-                                state := CollectSeqState.Finished
+                                state <- CollectSeqState.Finished
                                 dispose e2
                                 dispose e1
                                 x.Dispose()
@@ -790,6 +790,35 @@ module AsyncSeq =
                                 dispose e
                             | _ -> () }) :> AsyncSeq<'T>
 
+  let ofList (source: 'T list) : AsyncSeq<'T> =
+    AsyncSeqImpl(fun () ->
+        let mutable remaining = source
+        { new IAsyncSeqEnumerator<'T> with
+              member _.MoveNext() =
+                  async {
+                      match remaining with
+                      | [] -> return None
+                      | h :: t ->
+                          remaining <- t
+                          return Some h
+                  }
+              member _.Dispose() = () }) :> AsyncSeq<'T>
+
+  let ofArray (source: 'T []) : AsyncSeq<'T> =
+    AsyncSeqImpl(fun () ->
+        let mutable i = 0
+        { new IAsyncSeqEnumerator<'T> with
+              member _.MoveNext() =
+                  async {
+                      if i < source.Length then
+                          let v = source.[i]
+                          i <- i + 1
+                          return Some v
+                      else
+                          return None
+                  }
+              member _.Dispose() = () }) :> AsyncSeq<'T>
+
   let appendSeq (seq2: seq<'T>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
     append source (ofSeq seq2)
 
@@ -1982,35 +2011,35 @@ module AsyncSeq =
   let takeWhileInclusive (f : 'a -> bool) (s : AsyncSeq<'a>) : AsyncSeq<'a> =
     AsyncSeqImpl(fun () ->
         let en = s.GetEnumerator()
-        let fin = ref false
+        let mutable fin = false
         { new IAsyncSeqEnumerator<'a> with
             member _.MoveNext() = async {
-                if !fin then return None
+                if fin then return None
                 else
                     let! next = en.MoveNext()
                     match next with
                     | None -> return None
                     | Some a ->
                         if f a then return Some a
-                        else fin := true; return Some a }
+                        else fin <- true; return Some a }
           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
+        let mutable fin = false
         { new IAsyncSeqEnumerator<'T> with
             member _.MoveNext() = async {
-                if !fin then return None
+                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 }
+                        else fin <- true; return Some a }
           interface System.IDisposable with
             member _.Dispose() = en.Dispose() }) :> AsyncSeq<'T>
 
@@ -2160,6 +2189,15 @@ module AsyncSeq =
   let toArraySynchronously (source:AsyncSeq<'T>) = toArrayAsync source |> Async.RunSynchronously
   #endif
 
+  let cycle (source: AsyncSeq<'T>) : AsyncSeq<'T> =
+    asyncSeq {
+        let! arr = source |> toArrayAsync
+        if arr.Length > 0 then
+            while true do
+                for x in arr do
+                    yield x
+    }
+
   let partitionAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : Async<'T[] * 'T[]> = async {
     let trues = ResizeArray<'T>()
     let falses = ResizeArray<'T>()

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -60,6 +60,11 @@ module AsyncSeq =
     /// Creates an async sequence given by evaluating the specified async computation until it returns None.
     val replicateUntilNoneAsync : Async<'T option> -> AsyncSeq<'T>
 
+    /// Returns an async sequence which infinitely cycles through all elements of the source sequence.
+    /// The source is materialised into an array on first enumeration. Returns an empty sequence if
+    /// the source is empty.
+    val cycle : source:AsyncSeq<'T> -> AsyncSeq<'T>
+
     /// Returns an async sequence which emits an element on a specified period.
     val intervalMs : periodMs:int -> AsyncSeq<DateTime>
 
@@ -488,6 +493,14 @@ module AsyncSeq =
     /// input synchronous sequence and returns them one-by-one.
     val ofSeq : source:seq<'T> -> AsyncSeq<'T>
 
+    /// Creates an asynchronous sequence that lazily takes elements from an
+    /// F# list and returns them one-by-one.
+    val ofList : source:'T list -> AsyncSeq<'T>
+
+    /// Creates an asynchronous sequence that lazily takes elements from an
+    /// array and returns them one-by-one.
+    val ofArray : source:'T [] -> AsyncSeq<'T>
+
     /// Creates an asynchronous sequence that lazily takes element from an
     /// input synchronous sequence of asynchronous computation and returns them one-by-one.
     val ofSeqAsync : seq<Async<'T>> -> AsyncSeq<'T>

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -16,7 +16,7 @@
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <RepositoryType>git</RepositoryType>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <EnableSourceLink>true</EnableSourceLink>
+    <EnableSourceLink Condition="'$(FABLE_COMPILER)' != 'True'">true</EnableSourceLink>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="AsyncSeq.fsi" />