F# TaskBuilder：如何在不返回虚拟值以符合编译器约束的情况下引发异常？

Question

In a F# TaskBuilder task , I'm trying to catch an exception and re-throw it as wrapped exception:

open System.Threading.Tasks

open FSharp.Control.Tasks.V2


exception FakeDapperException of int

exception FakePersistenceException of string * exn


module FakeDapper =
    let executeWrongQueryAsync (sql: string) =
        task {
            raise (FakeDapperException(0))
            return 42
        }

module FakePersistenceLayer =
    let doSomeImportantDbRelatedStuffAsync (sql: string) =
        task {
            try
                return! FakeDapper.executeWrongQueryAsync sql
            with e ->
                FakePersistenceException(sql, e) |> raise
                return Unchecked.defaultof<int>
        }

module Task =
    let GetResult (task: Task<'T>) =
        task.GetAwaiter().GetResult()


[<EntryPoint>]
let main _ =
    let result =
        FakePersistenceLayer.doSomeImportantDbRelatedStuffAsync "this is some pretty sql stuff"
        |> Task.GetResult
    0

The code above works as expected, however, when I first implemented I wanted to have something like below:

let doSomeImportantDbRelatedStuffAsync (sql: string) =
    task {
        try
            return! FakeDapper.executeWrongQueryAsync sql
        with e ->
            FakePersistenceException(sql, e) |> raise
    }

which could not compile:

Program.fs(23, 17): [FS0001] Type mismatch. Expecting a 'FSharp.Control.Tasks.TaskBuilder.Step<int>' but given a 'FSharp.Control.Tasks.TaskBuilder.Step<unit>'. 
The type 'int' does not match the type 'unit'

This is due to the way the task CE works, but I am wondering if there is a way to not return a useless value (ie return Unchecked.defaultof<int> ) to stop the compiler yelling at me.

Answer 1

The problem is that raise does not know what type to infer, due to being in the task CE. Because the first branch try has a return the last branch must have one as well (this return is where the type inference comes in)

let doSomeImportantDbRelatedStuffAsync (sql: string) =
    task {
        try
            return! FakeDapper.executeWrongQueryAsync sql
        with e ->
            return FakePersistenceException(sql, e) |> raise
    }

This should make the type inference happy, as raise will infer the type of the task CE now.