Erlang 中的选择性接收

Question

所以我开始学习 Erlang，我对这段代码有点困惑。

 -module(prior).
 -compile(export_all).


    important() ->
      receive
    { Priority, Msg } when Priority > 10 ->
      [Msg | important()]
  after 0 ->
     normal()
  end.

normal() ->
  receive
    { _, Msg } -> 
      [Msg | normal()]
  after 0 ->
      []
  end.

我正在调用代码。

    10> self() ! {15, high}, self() ! {7, low}, self() ! {1, low}, self() ! {17, high}.
    {17,high}
    11> prior:important(). 
        [high,high,low,low]

我知道此代码将首先处理所有高优先级消息，然后是低优先级消息。我对返回值是 [high,high,low,low] 感到困惑，因为我看不到它们在哪里连接在一起。

Answer 1

它们在这里连接

[Msg | important()]

this important() 是一个函数，所以它有一个返回值，当你在 REPL 中运行它时，它会打印函数的返回值。此值是[Head | Tail] 列表从import() 构建的效果

important() 这是一个常规函数:)

有用吗？

Answer 2

所有 Erlang 函数总是返回一个值。函数important/0 将接收一个高优先级消息，然后在表达式[Msg | important()] 中递归调用自身，该表达式构建一个列表，其中包含最新的Msg 和important/0 将接收的所有其他消息。从important/0 返回的正是这个列表。当没有更多高优先级消息时，important/0 将改为调用normal/0 来读取所有剩余的消息。 normal/0 读取的消息将以与 important/0 相同的方式作为列表返回。这将返回给important/0，然后它将返回到与它返回消息相同的列表中。

请注意，一旦调用了normal/0，就不会再对高优先级消息进行特殊处理，因为再也不会调用important/0。此外，important/0 只会处理队列中已经存在的高优先级消息，因为一旦找不到更多消息，它就会调用normal/0。

超时值0的特殊之处在于它会立即超时，但保证首先搜索整个消息队列以查找匹配的消息。

Answer 3

最终的返回值是如何构造的……

[Msg | important()]第一次返回时，确定最终返回值的形式。唯一需要担心的是，我们还不知道最终返回值的所有细节。因此[Msg | important()] 中的important() 将继续被评估。下面举例说明最终返回值[high,high,low,low]是如何构造的。

[high | important(                      )]  <---- Defines the final form
        ---------------------------------
        [high | important(             )]   <---- Adds more details
                ------------------------
                normal(                )    <---- Adds more details
                ------------------------
                [low | normal(        )]    <---- Adds more details
                       ----------------
                       [low | normal()]     <---- Adds more details
                              --------
                              [      ]      <---- Adds more details
------------------------------------------
[high | [high | [low | [low | []]]]]
[high,high,low,low]                         <---- The final return value

代码的工作原理...

在函数important/0，after 0简单的意思是“我不等消息来”——如果我的邮箱里有消息，我会看；如果没有，我会继续（执行normal()）而不是在那里等待。邮箱里已经有{15, high}, {7, low}, {1, low}, {17, high}。在 Erlang 中，邮箱中的消息不以先到先得的顺序排队。 receive 子句可能很挑剔。它扫描邮箱中的所有邮件并“挑选”它想要的邮件。在我们的例子中，根据{Priority, Msg} when Priority > 10，{15, high} 和 {17, high} 首先被选中。 之后，函数normal/0 接管。 {7, low}, {1, low} 按顺序处理（consed）。最后，我们得到了[high,high,low,low]。

显示处理顺序的修改版本...

我们可以稍微修改一下代码，让处理（consing）的顺序更加明确：

-module(prior).
-compile(export_all).

important() ->
    receive
    {Priority, Msg} when Priority > 10 ->
        [{Priority, Msg} | important()] % <---- Edited
    after 0 ->
    normal()
    end.

normal() ->
    receive
    {Priority, Msg} -> % <---- Edited
        [{Priority, Msg} | normal()] % <---- Edited
    after 0 ->
        []
    end.

在 shell 中运行它：

4> c(prior).
{ok, prior}
5> self() ! {15, high}, self() ! {7, low}, self() ! {1, low}, self() ! {17, high}.
{17,high}
6> prior:important().
[{15,high},{17,high},{7,low},{1,low}]