Asynchronous 异步块中的返回位置，单位为F#

我有以下代码：

let private SendOk (payload: 'a) : WebPart =
    payload |> Json.serialize |> OK >=> Writers.setMimeType "application/json"


let getBTCBalance (addresses: string list) : Async<WebPart> =
    async {
        try
            let! reply = blockExplorer.GetMultiAddressAsync addresses |> Async.AwaitTask
            return reply.Addresses |> Seq.map (fun x -> x.FinalBalance.GetBtc()) |> SendOk
        with
        | :? ArgumentNullException as ex -> return BAD_REQUEST    ex.Message
        | ex                             -> return INTERNAL_ERROR ex.Message
    }

let getBTCBalance (addresses: string list) : Async<WebPart> =
    async {
        return ( 
            try
                let! reply = blockExplorer.GetMultiAddressAsync addresses |> Async.AwaitTask
                reply.Addresses |> Seq.map (fun x -> x.FinalBalance.GetBtc()) |> SendOk
            with
            | :? ArgumentNullException as ex -> BAD_REQUEST    ex.Message
            | ex                             -> INTERNAL_ERROR ex.Message
        )
    }

let private SendOk（有效负载：'a）:WebPart=
有效负载|>Json.serialize |>OK>=>Writers.setMimeType“application/Json”
让getBTCBalance（地址：字符串列表）：异步=
异步的{
尝试
let！reply=blockExplorer.GetMultiAddressAsync addresses |>Async.AwaitTask
返回reply.Addresses |>Seq.map（fun x->x.FinalBalance.GetBtc（））|>SendOk
具有
|：？ArgumentNullException as ex->返回错误请求ex.消息
|ex->返回内部错误ex.消息
}

它使用的是Suave web服务器，两个路径（ok和errors）都返回WebPart类型的对象

如果我尝试移动return语句来包装其他内容，则会得到以下代码：

let private SendOk (payload: 'a) : WebPart =
    payload |> Json.serialize |> OK >=> Writers.setMimeType "application/json"


let getBTCBalance (addresses: string list) : Async<WebPart> =
    async {
        try
            let! reply = blockExplorer.GetMultiAddressAsync addresses |> Async.AwaitTask
            return reply.Addresses |> Seq.map (fun x -> x.FinalBalance.GetBtc()) |> SendOk
        with
        | :? ArgumentNullException as ex -> return BAD_REQUEST    ex.Message
        | ex                             -> return INTERNAL_ERROR ex.Message
    }

let getBTCBalance (addresses: string list) : Async<WebPart> =
    async {
        return ( 
            try
                let! reply = blockExplorer.GetMultiAddressAsync addresses |> Async.AwaitTask
                reply.Addresses |> Seq.map (fun x -> x.FinalBalance.GetBtc()) |> SendOk
            with
            | :? ArgumentNullException as ex -> BAD_REQUEST    ex.Message
            | ex                             -> INTERNAL_ERROR ex.Message
        )
    }

让getBTCBalance（地址：字符串列表）：异步=
异步的{
报税表（
尝试
let！reply=blockExplorer.GetMultiAddressAsync addresses |>Async.AwaitTask
reply.Addresses |>Seq.map（fun x->x.FinalBalance.GetBtc（））|>SendOk
具有
|：？ArgumentNullException as ex->BAD_请求ex.消息
|ex->内部错误ex.消息
)
}

try/with块应该返回一个WebPart对象，我认为如果有一个单独的返回来包装它，它的可读性会更好

编译器不同意：

[FS0750]此构造只能在计算表达式中使用

---

我不明白为什么会这样。有人能给我解释一下吗？

那是因为你在用

let

let在异步计算中创建一个断点，将代码一分为二，第二部分作为延续传递（请参阅了解其工作原理）

不能将整个内容作为单个表达式返回，因为它实际上不是单个表达式，它看起来只是一个表达式。实际上，函数在
let之后结束和一个完全独立的函数开始

以下是问题的简化版本：

let f = async {
  return (let! x = doSomethingAsync)
}

这能让你更好地了解问题所在吗？
好的，是的，现在已经很清楚了。谢谢既然让我！是真的，这肯定是在隐瞒。