给定结果类型
type Result<'t> = OK of 't | Error of string
我有这些函数,它们都返回 Async < Result<'t>>,它们的组合如下:
let a = async { return Result.OK 1000 }
let b = async { return Result.Error "some message" }
let sum x y =
async {
let! r1 = x
match r1 with
| Result.OK v1 ->
let! r2 = y
match r2 with
| Result.OK v2 -> return v1 + v2
| Result.Error msg -> return Result.Error msg
| Result.Error msg -> return Result.Error msg
}
这段代码看起来很糟糕,所以我想要这样:
type Result = Ok of int | Error of string
type MyMonadBuilder() =
member x.Bind (v,f) =
async {
let! r = v
match r with
| Ok r' -> return! f r'
| Error msg -> return Error msg
}
member x.Return v = async {return Ok v }
member x.Delay(f) = f()
let mymonad = MyMonadBuilder()
let runMyMonad = Async.RunSynchronously
let a = mymonad { return 10 }
let b = mymonad { return 20 }
let c =
mymonad {
return Result.Error "Some message"
//??? The above doesn't work but how do I return a failure here?
}
let d =
async {
return Ok 1000
}
//how to wrap this async with mymonad such that I can use it together with my other computation expressions?
let sum x y =
mymonad {
let! v1 = x
let! v2 = y
return v1 + v2
}
[<EntryPoint>]
let main argv =
let v = sum a b |> runMyMonad
match v with
| Ok v' -> printfn "Ok: %A" v'
| Error msg -> printf "Error: %s" msg
System.Console.Read() |> ignore
0
所以问题是:
- 如何编写函数 c 使其在 mymonad 中返回错误?
- 如何编写函数 d,使其用 mymonad 包装 async?
- 如何以与 Async 类似的方式参数化我的 monad?
...这样我就可以写
let f (a:MyMonad<int>) (b:MyMonad<string>) = ...
更新:
此外,我想并行运行多个 mymonad 操作,然后查看结果数组以了解错误和成功的情况。因此,我认为使用异常不是一个好主意。
另外,关于问题 3,我的意思是让我的类型参数化并且不透明,这样调用者不知道/不关心他们正在处理异步。我编写 monad 的方式是调用者始终可以使用 Async.RunSynchronously 来运行 mymonad 表达式。
更新2:
到目前为止,我得到了以下结果:
- 我为 MyMonadBuilder 的每个成员使用显式类型
- 我将 ReturnFrom 添加到了 MyMonadBuilder。我使用此函数来包装 Async< Result<'t>>
- 我添加了诸如failwith之类的辅助函数,它创建了一个带有错误值的mymonad
代码如下所示:
type MyMonad<'t> = 't Result Async
type MyMonadBuilder() =
member x.Bind<'t> (v,f) : MyMonad<'t>=
async {
let! r = v
match r with
| Ok r' -> return! f r'
| Error msg -> return Error msg
}
member x.Return<'t> v : MyMonad<'t> = async {return Ok v }
member x.ReturnFrom<'t> v : MyMonad<'t> = v
member x.Delay(f) = f()
let failwith<'t> : string -> MyMonad<'t> = Result.Error >> async.Return
这对于我的目的来说看起来相当不错。谢谢!
最佳答案
异步工作流自动支持通过异常进行错误处理,因此惯用的解决方案是仅使用异常。如果你想区分一些特殊类型的错误,那么你可以定义一个自定义的异常类型:
exception MyError of string
// Workflow succeeds and returns 1000
let a = async { return 1000 }
// Workflow throws 'MyError' exception
// (using return! means that it can be treated as a workflow returning int)
let b = async { return! raise (MyError "some message") }
// Exceptions are automatically propagated
let sum = async {
let! r1 = a
let! r2 = b
return r1 + r2 }
如果要处理异常,可以使用try ... with MyError msg -> ...
在异步工作流程中。
您可以定义一个自定义计算构建器,使用代数数据类型(例如 Result
)重新实现此功能。 ,但除非您有充分的理由这样做,否则我不会推荐这种方法 - 它不适用于标准库,它非常复杂并且不适合一般的 F# 风格。
在您的计算表达式中,值的类型为 Async<Result<'T>>
, return
自动包装 'T
类型的参数在返回 Ok
的异步工作流程中。如果你想构造一个代表失败的值,你可以使用 return!
并创建一个返回 Result.Error
的异步工作流程。您可能需要这样的东西:
let c = mymonad {
return! async.Return(Result.Error "Some message")
}
let d = mymonad {
return 1000
}
但正如我所说,使用异常是更好的方法。
编辑:要回答评论中的问题 - 如果您有大量异步计算,您仍然可以将最终结果包装在自定义类型中。但是,您不需要重建整个异步工作流库 - 原始操作中的错误仍然可以使用标准异常进行处理:
// Primitive async work that may throw an exception
let primitiveAsyncWork = async { ... }
// A wrapped computation that returns standard Option type
let safeWork = async {
try
let! res = primitiveAsyncWork
return Some res
with e -> return None }
// Run 10 instances of safeWork in parallel and filter out failed computations
async { let! results = [ for i in 0 .. 9 -> safeWork ] |> Async.Parallel
return results |> Seq.choose id }
关于F# 自定义计算工作流程,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/18319305/