Add AsyncSeq.transpose — mirror Seq.transpose for async sequences

Transposes rows and columns of an AsyncSeq<seq<'T>>, yielding each
column as a 'T array. Buffers all rows before yielding columns.
Raises InvalidOperationException if inner sequences have different lengths.

- Signature in AsyncSeq.fsi
- 6 tests covering basic transpose, empty, single row, single column,
  singleton, and jagged-input error case
- RELEASE_NOTES.md: 4.9.0 entry

323/323 tests pass.

Co-authored-by: Copilot <[email protected]>

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 4.9.0
+
+* Added `AsyncSeq.transpose` — transposes an async sequence of sequences, yielding each column as an array; buffers all rows before yielding; mirrors `Seq.transpose`. Raises `InvalidOperationException` if inner sequences have different lengths.
+
 ### 4.8.0
 
 * Added `AsyncSeq.mapFoldAsync` — maps each element using an asynchronous folder that also threads an accumulator state, returning both the array of results and the final state; mirrors `Seq.mapFold`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -2035,6 +2035,18 @@ module AsyncSeq =
       let! arr = toArrayAsync source
       for i in arr.Length - 1 .. -1 .. 0 do
           yield arr.[i] }
+
+  /// Transposes the rows and columns of an async sequence of sequences.
+  /// Buffers the entire source sequence. Raises InvalidOperationException if inner sequences
+  /// have different lengths. Mirrors Seq.transpose.
+  let transpose (source: AsyncSeq<seq<'T>>) : AsyncSeq<'T[]> = asyncSeq {
+      let! rows = toListAsync (source |> map Seq.toArray)
+      if not rows.IsEmpty then
+          let firstLen = rows.Head.Length
+          if rows |> List.exists (fun row -> row.Length <> firstLen) then
+              invalidOp "The input sequences have different lengths."
+          for col in 0 .. firstLen - 1 do
+              yield rows |> List.map (fun row -> row.[col]) |> List.toArray }
   #endif
 
   #if !FABLE_COMPILER

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -673,6 +673,12 @@ module AsyncSeq =
     /// sequence is buffered before yielding any elements, mirroring Seq.rev.
     /// This function should not be used with large or infinite sequences.
     val rev : source:AsyncSeq<'T> -> AsyncSeq<'T>
+
+    /// Transposes the rows and columns of an async sequence of sequences, yielding each
+    /// column as an array. The entire source sequence is buffered before any column is yielded,
+    /// mirroring Seq.transpose. Raises InvalidOperationException if inner sequences have
+    /// different lengths. This function should not be used with large or infinite sequences.
+    val transpose : source:AsyncSeq<seq<'T>> -> AsyncSeq<'T[]>
     #endif
 
     /// Interleaves two async sequences of the same type into a resulting sequence. The provided

tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqTests.fs

@@ -3662,3 +3662,69 @@ let ``AsyncSeq.insertAt raises ArgumentException when index exceeds length`` ()
     |> AsyncSeq.toArrayAsync
     |> Async.RunSynchronously |> ignore)
   |> ignore
+
+// ===== transpose =====
+
+[<Test>]
+let ``AsyncSeq.transpose basic 2x3 matrix`` () =
+  let source =
+    asyncSeq {
+      yield seq { yield 1; yield 2; yield 3 }
+      yield seq { yield 4; yield 5; yield 6 }
+    }
+  let result = AsyncSeq.transpose source |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual(3, result.Length)
+  Assert.AreEqual([| 1; 4 |], result.[0])
+  Assert.AreEqual([| 2; 5 |], result.[1])
+  Assert.AreEqual([| 3; 6 |], result.[2])
+
+[<Test>]
+let ``AsyncSeq.transpose empty outer sequence yields empty`` () =
+  let result =
+    AsyncSeq.empty<seq<int>>
+    |> AsyncSeq.transpose
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([||], result)
+
+[<Test>]
+let ``AsyncSeq.transpose single row returns one column per element`` () =
+  let source = asyncSeq { yield seq { yield 1; yield 2; yield 3 } }
+  let result = AsyncSeq.transpose source |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual(3, result.Length)
+  Assert.AreEqual([| 1 |], result.[0])
+  Assert.AreEqual([| 2 |], result.[1])
+  Assert.AreEqual([| 3 |], result.[2])
+
+[<Test>]
+let ``AsyncSeq.transpose single column returns one row per element`` () =
+  let source =
+    asyncSeq {
+      yield seq { yield 1 }
+      yield seq { yield 2 }
+      yield seq { yield 3 }
+    }
+  let result = AsyncSeq.transpose source |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual(1, result.Length)
+  Assert.AreEqual([| 1; 2; 3 |], result.[0])
+
+[<Test>]
+let ``AsyncSeq.transpose of singleton rows yields one column`` () =
+  let source = asyncSeq { yield seq { yield 7 }; yield seq { yield 8 } }
+  let result = AsyncSeq.transpose source |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual(1, result.Length)
+  Assert.AreEqual([| 7; 8 |], result.[0])
+
+[<Test>]
+let ``AsyncSeq.transpose raises InvalidOperationException for jagged input`` () =
+  let source =
+    asyncSeq {
+      yield seq { yield 1; yield 2 }
+      yield seq { yield 3 }
+    }
+  Assert.Throws<System.InvalidOperationException>(fun () ->
+    AsyncSeq.transpose source
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+    |> ignore)
+  |> ignore