What is Pattern Matching in Erlang - erlang

Question

I'm learning Erlang and came across Pattern Matching.
Could someone kindly explain to me what is Pattern Matching using a simple explanation.
An explanation in which anybody could understand.
I have read multiple sources but still can't grasp the concept.

Answer 1

Could someone kindly explain to me what is Pattern Matching using a
simple explanation. An explanation in which anybody could understand.
Pattern matching is how assignment is instigated in erlang. In other languages, the = sign is the assignment operator, e.g. x = 10. However, in erlang, the = sign is the pattern match operator. When erlang sees an = sign, it looks at the term on the right hand side of the = sign, then tries to give values to the variables on the left hand side of the equals sign, so that both sides of the = sign are identical, i.e. they match.
In the simple case, e.g. X = 1, it looks like the = sign performs assignment in erlang. And in fact, X will have the value 1 after that statement is evaluated. However, you can't write the following in other languages:
{Y, 10} = {20, 10}
In other languages you can't have constants on the left hand side of the assignment operator. In erlang, however, specifying constants on the left of the pattern match operator is perfectly normal. After that statement is evaluated, Y will have the value 20 because in order for both sides of the = sign to be identical, erlang has to assign the value 20 to Y.
How does erlang perform that assignment? It doesn't really matter, but you can think of the assignment operator in erlang as the three characters !*!. When erlang sees the pattern match operator in the example above, in order to get things to match up, erlang uses the assignment operator !*! to assign the value 20 to Y, i.e. Y !*! 20.
When you write = in erlang, you are asking, "Please try to get these things to match!". The knock on effect is that erlang will perform some assignments (!*!) to make both sides match. You can't do assignment directly yourself, all you can do is ask erlang to make things match. If that is too confusing, then just think of the pattern match operator as a trick assignment operator, which is more powerful than the assignment operator in other languages. It doesn't matter what you call the = sign in erlang, you just need to know how it works.
In erlang, pattern matching can be used in a lot of different ways:
1) To extract positional values from a data structure:
15> [X, {Y, _}] = [10, {1, hello}].
[10,{1,hello}]
16> X.
10
17> Y.
1
2) To determine which function clause executes in a function definition:
my.erl:
go(X, hello) ->
io:format("Do stuff: ~w~n", [X*2]);
go(X, goodbye) ->
io:format("Do other stuff: ~w~n", [X-2]);
go(_, _) ->
io:format("Okay.~n").
In the shell:
7> c(my).
my.erl:2: Warning: export_all flag enabled - all functions will be exported
{ok,my}
8> my:go(3, 4).
Okay
ok
9> my:go(2, goodbye).
Do other stuff: 0
ok
10> my:go(10, hello).
Do stuff: 20
ok
In the first function call, erlang performs the following pattern match:
{X, hello} = {3, 4}
...which fails because no value that erlang can assign(!*!) to X will make both sides match. So, erlang continues on to the next function clause and performs the match:
{X, goodbye} = {3, 4}
which also fails; finally the third function clause matches, so the statements in the body of that function clause execute.
3) Case statements, list comprehensions, etc.

Answer 2

Consider this example of pattern matching in a function:
Eshell V8.2.1 (abort with ^G)
1> F = fun(1, X) -> "hello f1";
1> (2, X) -> "hello f2"
1> end.
#Fun<erl_eval.12.52032458>
2> F(1, 33).
"hello f1"
3> F(2, some_token).
"hello f2"
4> F(3, "...").
** exception error: no function clause matching erl_eval:'-inside-an-interpreted-fun-'(3,"...")
5>
The pattern matching against the first argument of function F enables to execute a branch of code or another.
Pattern matching is a way to:
guarantee that some conditions are met
have the code go into some specific branches (like if-then-else)
raise an error if an execution path is invalid
See also the official documentation page:
http://erlang.org/doc/reference_manual/patterns.html