1let readAsync (stream: System.IO.Stream) (buffer: byte[]) =
2    Async.FromBeginEnd(
3        (fun (cb, state) -> stream.BeginRead(buffer, 0, buffer.Length, cb, state)),
4        stream.EndRead)

1let workflow =
2    async {
3        try
4            let! bytes = readAsync stream buffer
5            return Ok bytes
6        with ex ->
7            return Error ex.Message
8    }

1Async.StartWithContinuations(
2    workflow,
3    (fun ok -> printfn "ok: %A" ok),
4    (fun err -> printfn "error: %s" err.Message),
5    (fun _ -> printfn "cancelled")
6)

1let safeRead =
2    async {
3        try
4            let! n = readAsync stream buffer
5            return n
6        with _ ->
7            return 0 // hides real I/O failure
8    }

let readTaskAsync stream buffer =
    stream.ReadAsync(buffer, 0, buffer.Length)
|> Async.AwaitTask ``` Modern Task-based APIs reduce APM edge cases and improve maintainability. ### 6. Test failure paths explicitly ```fsharp let testFailure () = async { try let! _ = failingWorkflow failwith "expected failure" with ex -> printfn "captured: %s" ex.Message } ``` Include callback-time failures and cancellation in test coverage. ## Common Pitfalls * Expecting APM operational errors to throw at `BeginX` call time. * Starting workflows with `Async.Start` and never observing exceptions. * Returning fallback values inside generic catch blocks that hide root causes. * Mixing APM wrappers and Task wrappers inconsistently in one code path. * Skipping failure-path tests for callback and `EndX` behavior. ## Summary `Async.FromBeginEnd` can handle exceptions correctly, but only if you observe and handle them at the async boundary where `EndX` results are consumed. Use `try/with` around `let!`, avoid fire-and-forget starts for critical workflows, and prefer Task-based APIs when available. With explicit observation and consistent error strategy, legacy APM interop in F# remains predictable and debuggable. For teams maintaining f asyncfrombeginend not catching exceptions in long-lived codebases, reliability improves when implementation guidance is paired with a lightweight verification routine. A practical pattern is to define three test categories up front. First, happy-path tests that validate normal expected inputs. Second, boundary tests that include empty values, minimum and maximum limits, and malformed records from real logs. Third, operational tests that simulate production-like behavior under retries, parallel execution, and partial failure. This combination catches both obvious logic defects and the subtle integration issues that usually appear after deployment. It is also useful to encode assumptions close to the code rather than leaving them in scattered documentation. Add short comments where invariants matter, keep helper utilities centralized, and avoid repeating slightly different logic in multiple modules. In CI, run a small deterministic suite on every commit and a broader dataset suite on schedule. When incidents occur, convert the failing scenario into a permanent regression test before patching. Over time this creates a strong feedback loop where f asyncfrombeginend not catching exceptions behavior remains stable even as dependencies, framework versions, and team ownership change. The result is less firefighting and faster review cycles.