In Erlang, there are two main types of message passing primitives that allow processes to communicate with each other:
1. `!` (Bang or exclamation mark operator) : The `
!` operator is the basic message sending primitive in Erlang. It is used to send a message from one process to another. The syntax for sending a message is `
SenderPid ! Message`, where `
SenderPid` is the process identifier (PID) of the sending process, and `
Message` is the data to be sent. The message is sent asynchronously, meaning the sending process does not wait for a response. The message is delivered to the recipient's mailbox for later processing.
Example :
ReceiverPid ! {self(), "Hello, world!"}.
2. `receive` block : The `
receive` block is used by processes to receive and handle incoming messages. It allows a process to wait for specific messages and pattern match on the received messages to perform different actions. The syntax of a
`receive` block is as follows:
receive
Pattern1 [when Guard1] -> Action1;
Pattern2 [when Guard2] -> Action2;
...
PatternN [when GuardN] -> ActionN
end
The process will wait until a matching message arrives in its mailbox. When a message matches one of the patterns, the corresponding action is executed. If no message matches any of the patterns, the process will block and wait for the next message.
Example :
receive
{SenderPid, Message} -> io:format("Received message: ~p~n", [Message])
end.
In the example above, the process waits to receive a message of the form `
{SenderPid, Message}` and then prints the received message.
These message passing primitives enable inter-process communication in Erlang. Processes can send and receive messages asynchronously, allowing for concurrent and loosely coupled communication. The use of message passing contributes to Erlang's fault-tolerant and scalable nature, as processes can communicate across nodes in a distributed system.
