blocks|key|1635543|text|请原谅我的新手，因为我正在学习F#。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1635544|我很好奇地看到使用RX代替MailboxProcessor，如果你有任何相关资料的链接。|1635545|根据我有限的理解，我会在我自己的代码中选择MbP，因为在F#中设置事件有点麻烦(我可以从本文：MSDN中学到)。你需要RX的事件来连接到对吗？|offset|length|1635546|与MbP一样，我所需要的只是一个受歧视的消息联合，一个在接收到给定消息时希望执行的函数列表。以及处理这件事的邮箱处理器。|1635547|在代码中，这一切看起来都很整洁。我可以把我的MbP放在一个模块中，然后我的“对象”模块看起来就像|1635548|记录|unordered-list-item|1635549|信息DU|1635550|带有一些将数据发布到MbP的getter和setter的包装器。|1635551|对我来说，这看起来比我用事件编写代码要整洁得多，正如我链接到的那篇MSDN文章所描述的那样。|1635552|虽然我只是一个小F#，所以我可能距离我的计算距离一英里，这是一个外观和感觉的事情，而不是一个适合的选择(因为我还没有资格作出那个决定)。|1635553|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd233189.aspx^0|0|0|1B|4|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@$F|17|G|18|1|19]]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1C|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|1D|8|@]|9|@]|A|$]]|$1|Q|3|R|5|N|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

Please excuse my newbie-ness as I'm just learning F#. 

I'm intrigued to see the use of RX in place of a MailboxProcessor, if you have any links to relevant materials.

With my limited understanding; I would choose MbP's in my own code as events are a bit messy to set up in F# (from what I can take from this article: <a href="http://msdn.microsoft.com/en-us/library/dd233189.aspx" rel="nofollow noreferrer">MSDN</a>). And you need events for RX to hook into right?

Where as with a MbP all I need is a discriminated union of messages, a list of functions I wish to be executed when a given message is received. And the mail box processor that handles this.

This all looks pretty neat in the code. I can bunch my MbP's together in a module then my "object" module looks like

<ul>
<li>Record</li>
<li>Message DU</li>
<li>Wrapper with some getters and setters that post data to the MbP</li>
</ul>

For me this looks a lot neater than it would If I wrote my code with events as described in that MSDN article I linked to.

Though I am just an F# junior so I may be a miles off with my reckoning and it is a look-&amp;-feel thing rather than a suitability-for-purpose choice (as I'm not qualified to make that call, yet)

blocks|key|1635580|text|我不确定这个问题的措辞是否合理--有许多不同的monad+(例如，标识单、列表单、选项单、.)，其中大部分与并发无关。此外，更多地了解您正在处理的特定场景将是有帮助的--“并发”是一个有点模糊的话题。根据您想要实现的目标，F#的async工作流(构建在Async+monad上)可能是您的最佳选择。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1635581|如果您正在使用F#，我建议您不要直接使用，因为这些库在通过F#访问时有一种非常陌生的感觉。但是，您可以创建愉快的F#包装器(例如现有的Seq和Observable模块)。此外，对于一元类型，您可以创建一个计算表达式生成器(例如，您可以使用反应性扩展创建一个构建器，这将使您能够使用计算表达式来构建和组合IObservable)。|1635582|entityMap^0|36|5|3I|5|0|1V|3|1Z|A|47|B|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

I'm not sure that the question makes sense as phrased - there are many different monads (e.g. the identity monad, the list monad, the option monad, ...), most of which have nothing to do with concurrency. Furthermore, it would be helpful to know more about the particular scenario that you're dealing with - "concurrency" is a bit of a nebulous topic. Depending on what you're trying to achieve, F#'s <code>async</code> workflows (which are built on the <code>Async</code> monad) might be your best bet.

If you're using F#, I'd recommend against using LINQ-to-anything directly, since those libraries have a very alien feel when accessed via F#. You could, however, create pleasant F# wrappers (such as the existing <code>Seq</code> and <code>Observable</code> modules). Additionally, for monadic types, you could create a computation expression builder (e.g. you could create a builder using the Reactive Extensions which would enable you to use computation expressions to build and compose <code>IObservable</code>s).

blocks|key|1635657|text|你会接受斯卡拉世界的答案吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1635658|如果你寻求“纯功能的替代演员模式”，那么请看一下保罗·丘萨诺的博客上的这篇伟大的文章。|1635659|pchiusano.blogspot.ro/2010/01/actors-are-not-good-concurrency-model.html+(存档于此：http://archive.is/NxNLc)|offset|length|1635660|以下是一些参考资料：|1635661|http://noelwelsh.com/programming/2013/03/04/why-i-dont-like-akka-actors/|1635662|演员不作曲，阿克卡的演员没有被有效的键入，类型系统是我们使用Scala的原因。|blockquote|1635663|https://opencredo.com/akka-typed/|1635664|不幸的是，当前的API存在一些缺陷，这些缺陷在很大程度上与类型安全性的缺乏有关。|1635665|http://doc.akka.io/docs/akka/snapshot/scala/typed.html|1635666|这个项目的现状和与Akka演员的关系是多年研究和以往尝试的结果(包括2.2.x系列中的类型化渠道)，而且它正在走向稳定，但要使Akka的核心概念成熟需要很长时间。
这样做的一个副作用是，现在可以在不需要打包到Actor的情况下对行为进行隔离测试，测试可以完全同步运行，而不必担心超时和虚假故障。另一个副作用是行为可以很好地组合和修饰。|1635667|价格合理的单片可组合应用体系结构|1635668|https://youtu.be/M258zVn4m2M?t=1955|unordered-list-item|1635669|https://youtu.be/M258zVn4m2M?t=1986|1635670|Heather提出的“函数传递样式”的概念可能是分布式函数编程模型的关键。|1635671|SF+Scala:+Heather，函数传递风格，一种新的分布式编程模型|1635672|更新12/2018+:现在我们可以使用Aecor，它提供了以下方法：|style|CODE|1635673|使用功能programming+model和|1635674|使用基于Akka的runtime|1635675|“行为属于域层，运行时在基础结构层中。”|1635676|资料来源：https://pavkin.ru/aecor-part-3/，http://aecor.io|1635677|entityMap|0|LINK|mutability|MUTABLE|url|http://pchiusano.blogspot.ro/2010/01/actors-are-not-good-concurrency-model.html|1|http://archive.is/NxNLc|2|3|4|5|https://www.youtube.com/watch?v=M258zVn4m2M&feature=youtu.be&t=1598|6|7|8|https://www.youtube.com/watch?v=4obTnLVXQWY|9|https://pavkin.ru/aecor-part-3/|10|http://aecor.io/^0|0|0|0|20|0|27|N|1|0|0|0|20|2|0|0|0|X|3|0|0|0|1I|4|0|0|0|G|5|0|0|Z|6|0|0|Z|7|0|0|0|10|8|0|J|5|0|4|H|0|4|4|9|7|0|0|5|V|9|11|F|A|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|27|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|28|8|@]|9|@$F|29|G|2A|1|2B]|$F|2C|G|2D|1|2E]]|A|$]]|$1|H|3|I|5|6|7|2F|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|2G|8|@]|9|@$F|2H|G|2I|1|2J]]|A|$]]|$1|L|3|M|5|N|7|2K|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2L|8|@]|9|@$F|2M|G|2N|1|2O]]|A|$]]|$1|Q|3|R|5|N|7|2P|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|2Q|8|@]|9|@$F|2R|G|2S|1|2T]]|A|$]]|$1|U|3|V|5|N|7|2U|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2V|8|@]|9|@$F|2W|G|2X|1|2Y]]|A|$]]|$1|Y|3|Z|5|10|7|2Z|8|@]|9|@$F|30|G|31|1|32]]|A|$]]|$1|11|3|12|5|10|7|33|8|@]|9|@$F|34|G|35|1|36]]|A|$]]|$1|13|3|14|5|6|7|37|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|38|8|@]|9|@$F|39|G|3A|1|3B]]|A|$]]|$1|17|3|18|5|6|7|3C|8|@$F|3D|G|3E|19|1A]]|9|@]|A|$]]|$1|1B|3|1C|5|10|7|3F|8|@$F|3G|G|3H|19|1A]]|9|@]|A|$]]|$1|1D|3|1E|5|10|7|3I|8|@$F|3J|G|3K|19|1A]|$F|3L|G|3M|19|1A]]|9|@]|A|$]]|$1|1F|3|1G|5|N|7|3N|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|3O|8|@]|9|@$F|3P|G|3Q|1|3R]|$F|3S|G|3T|1|3U]]|A|$]]|$1|1J|3|-4|5|6|7|3V|8|@]|9|@]|A|$]]]|1K|$1L|$5|1M|1N|1O|A|$1P|1Q]]|1R|$5|1M|1N|1O|A|$1P|1S]]|1T|$5|1M|1N|1O|A|$1P|K]]|1U|$5|1M|1N|1O|A|$1P|P]]|1V|$5|1M|1N|1O|A|$1P|T]]|1W|$5|1M|1N|1O|A|$1P|1X]]|1Y|$5|1M|1N|1O|A|$1P|Z]]|1Z|$5|1M|1N|1O|A|$1P|12]]|20|$5|1M|1N|1O|A|$1P|21]]|22|$5|1M|1N|1O|A|$1P|23]]|24|$5|1M|1N|1O|A|$1P|25]]]]

Would you accept answers from the Scala world?
If you seek &quot;a purely functional alternative to actor model&quot; then please see this great post from Paul Chiusano's blog
<a href="http://pchiusano.blogspot.ro/2010/01/actors-are-not-good-concurrency-model.html" rel="nofollow noreferrer">pchiusano.blogspot.ro/2010/01/actors-are-not-good-concurrency-model.html</a>
(archived here: <a href="http://archive.is/NxNLc" rel="nofollow noreferrer">http://archive.is/NxNLc</a>)
and some references below:
<a href="http://noelwelsh.com/programming/2013/03/04/why-i-dont-like-akka-actors/" rel="nofollow noreferrer">http://noelwelsh.com/programming/2013/03/04/why-i-dont-like-akka-actors/</a>
<blockquote>
Actors do not Compose
Akka’s Actors are not Usefully Typed
The type system is the reason we use Scala.
</blockquote>
<a href="https://opencredo.com/akka-typed/" rel="nofollow noreferrer">https://opencredo.com/akka-typed/</a>
<blockquote>
Unfortunately, the current API suffers from a few drawbacks, which are to a good degree associated with the lack of type safety
</blockquote>
<a href="http://doc.akka.io/docs/akka/snapshot/scala/typed.html" rel="nofollow noreferrer">http://doc.akka.io/docs/akka/snapshot/scala/typed.html</a>
<blockquote>
Status of this Project and Relation to Akka Actors
Akka Typed is the result of many years of research and previous attempts (including Typed Channels in the 2.2.x series) and it is on its way to stabilization, but maturing such a profound change to the core concept of Akka will take a long time
A side-effect of this is that behaviors can now be tested in isolation without having to be packaged into an Actor, tests can run fully synchronously without having to worry about timeouts and spurious failures. Another side-effect is that behaviors can nicely be composed and decorated
</blockquote>
<a href="https://www.youtube.com/watch?v=M258zVn4m2M&amp;feature=youtu.be&amp;t=1598" rel="nofollow noreferrer">Composable application architecture with reasonably priced monads</a>
<ul>
<li><a href="https://youtu.be/M258zVn4m2M?t=1955" rel="nofollow noreferrer">https://youtu.be/M258zVn4m2M?t=1955</a></li>
<li><a href="https://youtu.be/M258zVn4m2M?t=1986" rel="nofollow noreferrer">https://youtu.be/M258zVn4m2M?t=1986</a></li>
</ul>
The concept of &quot;function passing style&quot; from Heather Miller might be key to a distributed functional programming model.
<a href="https://www.youtube.com/watch?v=4obTnLVXQWY" rel="nofollow noreferrer">SF Scala: Heather Miller, Function-Passing Style, A New Model for Distributed Programming</a>
Update 12/2018 : now we can use <code>Aecor</code> which provide the means to:
<ul>
<li>implement business domain logic with a functional <code>programming model</code> and</li>
<li>use an <code>Akka</code> based <code>runtime</code></li>
</ul>
<blockquote>
&quot;behaviors belong to the domain layer and runtime is out there in the infrastructure layer.&quot;
</blockquote>
Source: <a href="https://pavkin.ru/aecor-part-3/" rel="nofollow noreferrer">https://pavkin.ru/aecor-part-3/</a>, <a href="http://aecor.io" rel="nofollow noreferrer">http://aecor.io</a>

I've been trying to find anything that discusses when you should favor the use of monads over actors (in concurrency scenarios), but I've found nothing. In particular, I'm wondering about the use of the Reactive Extensions (LINQ to Events) vs. F#'s MailboxProcessor. Please give examples in addition to any philosophical reasoning you might have.

Update
For better context, the Reactive Extensions implement the continuation monad in the form of IObservable/IObserver. I'm not necessarily saying I have to use F#, just that F# has a concrete "actor model" available in a .NET language in the form of MailboxProcessor&lt;'T>.

What I'm trying to understand is when to use a monad (in this case a continuation monad) vs. an actor model for concurrency purposes. Where the monad (as I understand it) doesn't introduce state, the actor has its own internal state that is modified as necessary to provide protected access.

I've seen a number of examples of using both: Rx and node.js (CPS, not really the continuation monad) vs. F#'s MailboxProcessor and Scala's Akka framework. I just don't know why you would choose one over the other.

Monads and Actors

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我一直在试图找到任何关于什么时候应该使用monads而不是参与者(在并发场景中)的讨论，但我什么也没有发现。特别是，我想知道反应性扩展(LINQ )与F#的MailboxProcessor之间的关系。除了任何哲学推理之外，还请给出一些例子。为了获得更好的上下文，更新，反应性扩展以IObservable/i观察者的形式实...

问单子和演员
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问单子和演员EN