3

我在这里有一个多状态 F# MailboxProcessor 示例，只是想知道为什么它可以编译但行为出乎意料 - F# 代理可以在传入的 lambda 函数中只有一个 inbox.Receive() 语句吗？我正在尝试遵循“Expert F# 3.0”第 284 页中提供的一般示例模式，其中使用多个 async {} 主体允许多个状态，但没有具体说明是否可以使用 inbox.Receive()在每个异步？

open System

let mb1<'T> = MailboxProcessor<string>.Start(fun inbox ->
                        let rec loop1 (n:int) = async {
                                    printfn "loop1 entry "
                                    let! msg = inbox.Receive()
                                    do! Async.Sleep(1000)
                                    printfn "loop1 calling loop2"  //msg received %A" msg
                                    return! loop2 (n+1) }

                        and loop2 (x:int) =     async {
                                    printfn "loop2 entry"
                                    let! msg2 = inbox.Receive()
                                    printfn "loop2 msg received %A" msg2
                                    printfn "loop2 calling loop1"
                                    return! loop1 (x+1) }
        loop2 0                    
                                        )

mb1.Post("data message 1")
mb1.Post("data message 2")

产量

loop2 entry
loop2 msg received "data message 1"
loop2 calling loop1
loop1 entry 
val it : unit = ()
> 
loop2 entry
loop2 msg received "data message 2"
loop2 calling loop1
loop1 entry 
val it : unit = ()
>

所以让！跳过循环 1 中的 msg = inbox.Receive()？我原以为loop2是由return完成的！loop1 和那个让！inbox.Receive() 的分配特定于它使用的异步块。

4

1 回答 1

5

这与所谓的“价值限制”有关。

因为你给出了mb1一个显式的泛型参数，所以它被编译为一个函数，而不是一个值。无需过多详细说明，编译器必须这样做以促进使用不同泛型参数访问值的可能性。

结果，每次“引用”mb1时，实际发生的是一个创建全新代理的函数调用，因此这两个.Post调用发生在不同的对象上。

要纠正这种情况，请从值中删除通用参数，从而使其成为真正的一次性计算值：

let mb1 = MailboxProcessor<string>( ...

或者确保你只调用一次：

let mb = mb1
mb.Post("data message 1")
mb.Post("data message 2")
于 2017-05-26T20:40:27.450 回答