List Erlang：为列表中的每个元素循环一个函数

我有一个calls.txt：

{john, [jill,joe,bob]}.

{jill, [bob,joe,bob]}.

{sue, [jill,jill,jill,bob,jill]}.

{bob, [john]}.

{joe, [sue]}.

我想通过Receiver1循环，并为Receiver1中的每个元素调用spawner（）函数。但是，当我在控制台中调用read（）时，什么也没有发生。请帮忙

这是我的密码：

read() -> 
    {ok, [List1, List2, List3, List4, List5]} = 
    file:consult("calls.txt"),
    {Sender1, Receiver1} = List1,
    {Sender2, Receiver2} = List2,
    {Sender3, Receiver3} = List3,
    {Sender4, Receiver4} = List4,
    {Sender5, Receiver5} = List5,
    [spawner(Sender1,H) || H <- Receiver1].

spawner(Sname,Rname) ->
    Sender = spawn(calling,intercept,[]),
    Sender ! {self(), {Sname,Rname}},
    get_feedback().

get_feedback() ->
    receive
        {Msg} -> 
            io:fwrite(Msg)
    end.

read（）->
{好的，[List1，List2，List3，List4，List5]}=
文件：consult（“calls.txt”），
{Sender1，Receiver1}=List1，
{Sender2，Receiver2}=List2，
{Sender3，Receiver3}=List3，
{Sender4，Receiver4}=List4，
{Sender5，Receiver5}=List5，
[产卵器（发送器1，H）| H
Sender=spawn（调用、截获、[]），
发送者！{self（），{Sname，Rname}，
获取反馈（）。
获取反馈（）->
接收
{Msg}->
io:fwrite（Msg）
结束。

get\u feedback（）

在主/原始进程中执行。仅仅因为调用

get\u feedback（）

发生在调用

spawn（）

之后，并不意味着

get\u feedback（）

在派生进程中执行。在派生进程中执行的唯一事情是函数

调用：intercept（）

因此，您最终会向衍生进程发送消息，然后在调用

get\u feedback（）

时在主进程中输入一个

receive

——这意味着主进程等待衍生进程的消息，但衍生进程不发送任何消息（或者至少您还没有显示生成的进程向主进程发送消息的任何代码）

如果在函数

调用：intercept（）

中调用

get\u feedback（）

，则

get\u feedback（）

将在派生进程中执行，并且接收将尝试将主进程发送的消息与派生进程相匹配

此外，如果出于某种原因，接收与消息不匹配，并且您认为应该这样做，那么请按照以下方式重写接收：

receive 
    Msg -> io:format("~w~n", [Msg])
end

该接收将匹配任何消息，然后您可以检查输出以确定实际接收不匹配的原因

或者，您可以让

intercept（）

将消息发送回主进程，然后

get\u feedback（）

可以在主进程中接收消息：

-module(my).
-compile(export_all).

read() ->
    {ok, Pairs} = file:consult("calls.txt"),
    [spawner(Sender, Receivers) || {Sender, Receivers} <- Pairs]. 

spawner(Sender, Receivers) ->
    io:format("~w, ~w~n", [Sender, Receivers]),
    Pid = spawn(my, intercept, []),
    io:format("The main process is: ~w.~n", [self()]),
    io:format(
        "The newly spawned process where intercept() is executing is: ~w~n", 
        [Pid]
     ),

    Pid ! {self(), {Sender, Receivers} },
    get_feedback().


intercept() ->
    receive
        {From, Pair} -> 
            io:format("intercept() received message: ~w, from: ~w~n", [Pair, From]),
            From ! {self(), "hello"}
    end.

get_feedback() ->
    receive
        {From, Msg} ->
            io:format("Main process received message: ~p, from: ~w~n", [Msg, From])
    end.

-模块（my）。
-编译（全部导出）。
read（）->
{ok，Pairs}=file:consult（“calls.txt”），
[产卵器（发送者，接收者）|{发送者，接收者}
io:格式（“~w，~w~n”，[Sender，Receivers]），
Pid=spawn（my，intercept，[]），和，
io:format（“主进程是：~w.~n”，[self（）]），
io:格式(
“执行intercept（）的新生成的进程是：~w~n”，
[Pid]
),
Pid！{self（），{Sender，Receivers}，
获取反馈（）。
截取（）->
接收
{From，Pair}->
io:format（“intercept（）接收到的消息：~w，from:~w~n，[Pair，from]），
来自！{self（），“hello”}
结束。
获取反馈（）->
接收
{From，Msg}->
io:format（“主进程收到消息：~p，发件人：~w~n，[Msg，发件人]）
结束。

在外壳中：

18> c(my).    
my.erl:2: Warning: export_all flag enabled - all functions will be exported
{ok,my}

19> my:read().
john, [jill,joe,bob]
The main process is: <0.64.0>.
The newly spawned process where intercept() is executing is: <0.168.0>
intercept() received message: {john,[jill,joe,bob]}, from: <0.64.0>
Main process received message: "hello", from: <0.168.0>
jill, [bob,joe,bob]
The main process is: <0.64.0>.
The newly spawned process where intercept() is executing is: <0.169.0>
intercept() received message: {jill,[bob,joe,bob]}, from: <0.64.0>
Main process received message: "hello", from: <0.169.0>
sue, [jill,jill,jill,bob,jill]
The main process is: <0.64.0>.
The newly spawned process where intercept() is executing is: <0.170.0>
intercept() received message: {sue,[jill,jill,jill,bob,jill]}, from: <0.64.0>
Main process received message: "hello", from: <0.170.0>
bob, [john]
The main process is: <0.64.0>.
The newly spawned process where intercept() is executing is: <0.171.0>
intercept() received message: {bob,[john]}, from: <0.64.0>
Main process received message: "hello", from: <0.171.0>
joe, [sue]
The main process is: <0.64.0>.
The newly spawned process where intercept() is executing is: <0.172.0>
intercept() received message: {joe,[sue]}, from: <0.64.0>
Main process received message: "hello", from: <0.172.0>
[ok,ok,ok,ok,ok]

18>c（我的）。
my.erl:2:警告：已启用导出\u所有标志-将导出所有功能
{好的，我的}
19> 我的：read（）。
约翰[吉尔，乔，鲍勃]
主要流程是：。
正在执行intercept（）的新生成的进程是：
intercept（）收到消息：{john，[jill，joe，bob]}，来自：
主进程收到消息：“你好”，来自：
吉尔，[鲍勃，乔，鲍勃]
主要流程是：。
正在执行intercept（）的新生成的进程是：
intercept（）收到消息：{jill，[bob，joe，bob]}，来自：
主进程收到消息：“你好”，来自：
苏，[吉尔，吉尔，吉尔，鲍勃，吉尔]
主要流程是：。
正在执行intercept（）的新生成的进程是：
intercept（）收到消息：{sue，[jill，jill，jill，bob，jill]}，来自：
主进程收到消息：“你好”，来自：
鲍勃[约翰]
主要流程是：。
正在执行intercept（）的新生成的进程是：
intercept（）收到消息：{bob，[john]}，来自：
主进程收到消息：“你好”，来自：
乔[苏]
主要流程是：。
正在执行intercept（）的新生成的进程是：
intercept（）收到消息：{joe，[sue]}，来自：
主进程收到消息：“你好”，来自：
[好，好，好，好，好]