1open System
2
3let riskyWork = async {
4    printfn "Starting work..."
5    failwith "Something went wrong"  // Unhandled exception
6}
7
8// This try/catch does NOT catch the exception
9try
10    Async.Start riskyWork
11with
12| ex -> printfn "Caught: %s" ex.Message // The exception crashes the process — try/catch is useless here printfn "This line runs, then the process crashes" ``` `Async.Start` returns `unit` immediately. The async computation runs later on a thread pool thread. The `try/with` only wraps the call to `Async.Start` (which does not throw), not the computation itself. ## Fix 1: Handle Exceptions Inside the Async Block The simplest approach — wrap the async body in `try/with`: ```fsharp let safeWork = async { try printfn "Starting work..." failwith "Something went wrong" with | ex -> printfn "Caught inside async: %s" ex.Message } Async.Start safeWork // Output: Caught inside async: Something went wrong // No crash ``` This keeps the exception within the async computation and prevents it from reaching the thread pool. ## Fix 2: Async.StartWithContinuations Provide explicit success, error, and cancellation handlers: ```fsharp let riskyWork = async { printfn "Starting work..." failwith "Something went wrong" return 42 } Async.StartWithContinuations( riskyWork, (fun result -> printfn "Success: %d" result), (fun ex -> printfn "Error: %s" ex.Message), (fun cancel -> printfn "Cancelled: %s" cancel.Message) ) // Output: Error: Something went wrong ``` This gives full control over all three outcomes without modifying the original async computation. ## Fix 3: Async.Catch `Async.Catch` wraps the result in a `Choice` — either the value or the exception: ```fsharp let riskyWork = async { failwith "Something went wrong" return 42 } let handledWork = async { let! result = Async.Catch riskyWork match result with | Choice1Of2 value -> printfn "Success: %d" value | Choice2Of2 ex -> printfn "Caught: %s" ex.Message } Async.Start handledWork // Output: Caught: Something went wrong ``` This is useful when composing async workflows — you can catch errors from sub-computations without crashing. ## Fix 4: Async.StartAsTask Convert to a `Task<T>` and observe the exception through the Task: ```fsharp open System.Threading.Tasks let riskyWork = async { failwith "Something went wrong" return 42 } let task = Async.StartAsTask riskyWork // Option A: Await the task (in another async or Task-based context) task.ContinueWith(fun (t: Task<int>) -> if t.IsFaulted then printfn "Task error: %s" t.Exception.InnerException.Message else printfn "Task result: %d" t.Result ) | > ignore // Option B: In an async block let observe = async { try let! result = Async.AwaitTask task printfn "Result: %d" result with |
13| --- | --- | --- | --- | --- |
14| `Async.Start` | `unit` | No | Must handle inside or use continuations |
15| `Async.RunSynchronously` | `'T` | Yes | `try/with` around the call works |
16| `Async.StartAsTask` | `Task<'T>` | No | Via `Task.Exception` or `await` |
17| `Async.StartWithContinuations` | `unit` | No | Explicit error callback |
18| `Async.StartImmediate` | `unit` | Partial | Must handle inside |
19
20## Cancellation Handling
21
22```fsharp
23open System.Threading
24
25let cts = new CancellationTokenSource()
26
27let cancelableWork = async {
28    for i in 1..100 do
29        printfn "Step %d" i
30        do! Async.Sleep 100
31}
32
33Async.StartWithContinuations(
34    cancelableWork,
35    (fun () -> printfn "Done"),
36    (fun ex -> printfn "Error: %s" ex.Message),
37    (fun _ -> printfn "Cancelled"),
38    cts.Token
39)
40
41// Cancel after 500ms
42Thread.Sleep 500
43cts.Cancel()
44// Output: Step 1, Step 2, Step 3, Step 4, Cancelled