F# MailboxProcessor只是复制IObservable吗？

我想处理到消息的类型

添加x

使程序记住数字x

打印

可打印所有记忆中的数字

我为什么要写这个：

open System
type Message =
    | Add of int
    | Print
let mailbox = new MailboxProcessor<Message>(fun inbox -> 
        let rec loop history = async{
            let! msg=inbox.Receive()
            match msg with
                | Add x -> return! loop(history + x.ToString()+" ")
                | Print ->
                    printfn "%s" history
                    return! loop(history)
        }
        loop ""
    )
[<EntryPoint>]
let main argv = 
    mailbox.Start()
    mailbox.Post(Add 12)
    mailbox.Post(Add 56)
    mailbox.Post(Print)
    mailbox.Post(Add 34)
    mailbox.Post(Print)
    ignore <| Console.ReadLine()
    0

开放系统
类型消息=
|整数相加
|印刷品
让邮箱=新邮箱处理器（有趣的收件箱->
让rec循环历史=异步{
let！msg=inbox.Receive（）
配味精
|添加x->return！循环（历史+x.ToString（）+“”）
|打印->
printfn“%s”历史记录
返回！循环（历史记录）
}
循环“”
)
[]
让主argv=
mailbox.Start（）
邮箱.Post（添加12个）
邮箱.Post（添加56）
邮箱.邮寄（打印）
邮箱.邮政（添加34）
邮箱.邮寄（打印）
忽略可观察。扫描（趣味历史信息->
配味精
|添加x->history+x.ToString（）+“”
|打印->
printfn“%s”历史记录
历史
) ""
|>可观察。订阅（乐趣->（））
|>忽略
subject.OnNext（添加12）
主题.OnNext（添加56）
主题.OnNext（打印）
主题.OnNext（添加34）
主题.OnNext（打印）
忽略不，它们不是彼此的重复
MailboxProcessor
和
IObservable
分别是两种不同计算模型的底层构建块—参与者模型和函数式反应式编程

两者都处理异步性，但强调。正如您在简单示例中所注意到的那样，您可以根据一个或另一个构建解决方案，但您会发现在特定上下文中使用一个或另一个更为自然

MailboxProcessors
对于线程安全、无锁地访问资源（如文件）特别有用。您可以让多个线程通过异步接口操作资源，并且
MailboxProcessor
保证一次只处理其中一个请求

open System
open System.Reactive.Subjects
type Message =
    | Add of int
    | Print
let subject = new Subject<Message>() 
[<EntryPoint>]
let main argv = 
    subject
        |> Observable.scan(fun history msg -> 
                match msg with
                        | Add x -> history + x.ToString()+" "
                        | Print ->
                            printfn "%s" history
                            history
            ) ""
        |> Observable.subscribe(fun _->())
        |> ignore
    subject.OnNext(Add 12)
    subject.OnNext(Add 56)
    subject.OnNext(Print)
    subject.OnNext(Add 34)
    subject.OnNext(Print)
    ignore <| Console.ReadLine()
    0