计算表达式 vs 应用函子等等

Question

不完全确定标题描述是否正确，但我确实有以下代码：

paket.dependencies:

source https://www.nuget.org/api/v2
nuget fsharpx.extras
nuget mongodb.driver

some.fsx:

#r @".\packages\MongoDB.Bson\lib\net45\MongoDB.Bson.dll"
#r @".\packages\MongoDB.Driver\lib\net45\MongoDB.Driver.dll"
#r @".\packages\MongoDB.Driver.Core\lib\net45\MongoDB.Driver.Core.dll"

#r @".\packages\FSharpX.Extras\lib\net45\FSharpX.Extras.dll"


open MongoDB
open MongoDB.Driver
open MongoDB.Bson 
open MongoDB.Bson.Serialization

open FSharpx.Choice

let private createClient (connectString:string) = MongoClient(connectString)
let CreateClient = protect createClient

let private getDb name (client:IMongoClient) = client.GetDatabase(name)
let GetDB1 name client =
    choose {
        let! c = client
        return! (protect (getDb name) c)
    }

let GetDB2 name (client:Choice<IMongoClient, exn>) =
    protect (getDb name)
    <!> client

此 "excersise" 的要点是编写 GetDB2，使其与 GetDB1 的功能相同，但使用运算符（应用程序？），但我目前无法转过头来管理它。

上面的代码可以编译，但是签名 GetDB1 和 GetDB2 不相等，我显然在做某事不对。

val GetDB1 :
  name:string ->
    client:Choice<#MongoDB.Driver.IMongoClient,exn> ->
      Choice<MongoDB.Driver.IMongoDatabase,exn>

val GetDB2 :
  name:string ->
    client:Choice<MongoDB.Driver.IMongoClient,exn> ->
      Choice<Choice<MongoDB.Driver.IMongoDatabase,exn>,exn>

我在 GetDB2 中尝试了几个版本和操作顺序，但我或多或少总是以与上面相同的签名结束。

我最初的总体想法是编写小函数来完成它们应该做的事情，然后添加异常处理（protect），然后是 "wrap" 和 "unwrap" 相应地。

这当然也可能不是完全正确的想法。

是否有人可以在这里为我指明进一步研究、代码示例或其他方面的方向？实际上，此时欢迎任何类型的评论 ;-)

FSharpx doc

附录

我认为下面的应该和上面的差不多，但是没有 mongodb 依赖。

#r @".\packages\FSharpX.Extras\lib\net45\FSharpX.Extras.dll"

type DataBase = 
    {
        Name: string
    }

type Client = 
    {
        connectString: string
    } with member this.GetDatabase name = {
                        Name = name
                    }

open FSharpx.Choice
let private createClient (connectString:string) = {
  connectString= connectString
}

let CreateClient = protect createClient

let private getDb name (client:Client) = client.GetDatabase name

let GetDB1 name client =
    choose {
        let! c = client
        return! (protect (getDb name) c)
    }

let GetDB2 name client =
    protect (getDb name)
    <!> client

Answer 1

您在此处获得类型的复合，因为您使用了 <!> 运算符，即 map。定义如下：

let map f = function
    | Choice1Of2 value = Choice1Of2 (f value)
    | Choice2Of2 fail  = Choice2Of2 fail

这具有签名 ('T -> 'U) -> Choice<'T,'Failure> -> Choice<'U,'Failure>，即函数 f 用作映射 inside choice 类型。例如：

map (sprintf "%d")

类型为 Choice<int, 'Failure> -> Choice<string, 'Failure>。这对于应用不使用 Choice 类型的函数很有用 - 只有一个可能的失败点，并且发生在调用 map.

之前

然而，您的下一个函数生成 Choice 类型，但它采用非 Choice 类型。这意味着您希望错误传播 - 如果值中有错误，则选择它。如果值没问题，但函数中有错误，则使用它。如果一切顺利，就使用它。这要求两种错误类型相同，对您来说它们是 (exn).

这是描述 bind 操作，定义如下：

let bind f = function
    | Choice1Of2 value = f value
    | Choice2Of2 fail  = Choice2Of2 fail

签名 ('T -> Choice<'U,'Failure>) -> Choice<'T,'Failure> -> Choice<'U,'Failure>.

请注意 bind 与 map 非常相似，只是后者将结果提升为 Choice1Of2 - 映射函数始终成功。

在 FSharpX 中，您可以通过类似 |> 的运算符 >>= 或类似 <| 的运算符 <<=.[= 访问 bind。 57=]

最后，protect 是一种将抛出的异常捕获到 Choice2Of2 exn 中的奇特方法。和map类似，传递的函数是'T -> 'U类型，但是函数也可以抛出异常，传递的类型是notaChoice。 protect 定义如下：

let protect f x =
    try
        Choice1Of2 (f x)
    with
        exn -> Choice2Of2 exn

所以它的签名是('T -> 'U) -> 'T -> Choice<'U, exn>.

有关如何实施所有内容的更多信息，请参阅 the source of this computation expression。

综上所述，我们可以看出您的示例出错的原因。

getDb name 是一个函数 Client -> DataBase
protect (getDb name) 是一个函数 Client -> Choice<DataBase, exn>
map (protect (getDb name)) 因此是一个函数 Choice<Client, exn> -> Choice<Choice<DataBase, exn>, 'Failure>，因为 map 在 Choice.

不过，你想要的是

let GetDB name client =
    bind (protect (getDb name)) client

或运算符形式，

let GetDB name client = client >>= protect (getDb name)

一般来说，如果您的映射函数具有签名 'T -> 'U，您需要 map。如果它有 'T -> Choice<'U, 'Failure>，你想要 bind.

计算表达式 vs 应用函子等等

Computation expressions vs applicative functors and what not

monads

f#

computation-expression

fsharpx