Merge pull request #321 from fsprojects/repo-assist/fix-async-awaittask-129-2026-03-2c2c8da1e1b359c3

[Repo Assist] fix: async { for x in taskSeq } no longer wraps exceptions in AggregateException

Author: dsyme

release-notes.txt

@@ -2,6 +2,7 @@
 Release notes:
 
 0.6.0
+    - fixes: async { for item in taskSeq do ... } no longer wraps exceptions in AggregateException, #129
     - adds TaskSeq.compareWith and TaskSeq.compareWithAsync
     - adds TaskSeq.scan and TaskSeq.scanAsync, #289
     - adds TaskSeq.pairwise, #289

src/FSharp.Control.TaskSeq.Test/TaskSeq.AsyncExtensions.Tests.fs

@@ -1,5 +1,6 @@
 module TaskSeq.Tests.AsyncExtensions
 
+open System
 open Xunit
 open FsUnit.Xunit
 
@@ -115,6 +116,44 @@ module SideEffects =
         sum |> should equal 465 // eq to: List.sum [1..30]
     }
 
+module ExceptionPropagation =
+    [<Fact>]
+    let ``Async-for CE propagates exception without AggregateException wrapping`` () =
+        // Verifies fix for https://github.com/fsprojects/FSharp.Control.TaskSeq/issues/129
+        // Async.AwaitTask previously wrapped all task exceptions in AggregateException,
+        // breaking try/catch blocks in async {} expressions that expect the original type.
+        let run () = async {
+            let values = taskSeq { yield 1 }
+
+            try
+                for _ in values do
+                    raise (InvalidOperationException "test error")
+            with :? InvalidOperationException ->
+                ()
+        }
+
+        // Should complete without AggregateException escaping
+        run () |> Async.RunSynchronously
+
+    [<Fact>]
+    let ``Async-for CE try-catch catches original exception type, not AggregateException`` () =
+        // Verifies that the original exception type is visible in catch blocks,
+        // not wrapped in AggregateException as Async.AwaitTask used to do.
+        let mutable caughtType: Type option = None
+
+        let run () = async {
+            let values = taskSeq { yield 1 }
+
+            try
+                for _ in values do
+                    raise (ArgumentException "test")
+            with ex ->
+                caughtType <- Some(ex.GetType())
+        }
+
+        run () |> Async.RunSynchronously
+        caughtType |> should equal (Some typeof<ArgumentException>)
+
 module Other =
     [<Fact>]
     let ``Async-for CE must call dispose in empty taskSeq`` () = async {

src/FSharp.Control.TaskSeq/AsyncExtensions.fs

@@ -3,10 +3,30 @@ namespace FSharp.Control
 [<AutoOpen>]
 module AsyncExtensions =
 
+    // Awaits a Task<unit> without wrapping exceptions in AggregateException.
+    // Async.AwaitTask wraps task exceptions in AggregateException, which breaks try/catch
+    // blocks in async {} expressions that expect the original exception type.
+    // See: https://github.com/fsprojects/FSharp.Control.TaskSeq/issues/129
+    let private awaitTaskCorrect (task: System.Threading.Tasks.Task<unit>) : Async<unit> =
+        Async.FromContinuations(fun (cont, econt, ccont) ->
+            task.ContinueWith(fun (t: System.Threading.Tasks.Task<unit>) ->
+                if t.IsFaulted then
+                    let exn = t.Exception
+
+                    if exn.InnerExceptions.Count = 1 then
+                        econt exn.InnerExceptions.[0]
+                    else
+                        econt exn
+                elif t.IsCanceled then
+                    ccont (System.OperationCanceledException "The operation was cancelled.")
+                else
+                    cont ())
+            |> ignore)
+
     // Add asynchronous for loop to the 'async' computation builder
     type Microsoft.FSharp.Control.AsyncBuilder with
 
         member _.For(source: TaskSeq<'T>, action: 'T -> Async<unit>) =
             source
             |> TaskSeq.iterAsync (action >> Async.StartImmediateAsTask)
-            |> Async.AwaitTask
+            |> awaitTaskCorrect