Intro
Once of interesting features of Elixir is pattern matching. That is way to save your time and similar with the way of our thinking.
Pattern matching help us to check value, extract value from complex term, branching code.
It also is a way to fail fast, follow "Let it crash" (and supervisor will fix) idiomatic of Erlang.
How to uses
Pattern matching is always return original term (value of variable/expression) for us can continue using it for other expression.
Three things we need to care in here:
- If does not match it will raise an error.
- Pattern matching is always return original term.
- If we add a variable for extracting, after matched variable will have value we expected.
With '=', pattern is in the left side, original term in right side.
We can use many patterns in an expression like:
{:ok, result} = {:ok, {total, list}} = {:ok, {1, ["hi"]}}
or
{:ok, {total, list} = result} = {:ok, {1, ["hi"]}}
With function, pattern is placed in argument.
No we go to two use cases for using pattern matching.
check similar(condition) value
This type of pattern matching can help us verify a value, format of variable/param.
Term is matched with pattern ({:ok, "hello"} = {:ok, "hello"}):
(check value and return original term)
Term is unmatched with pattern ({:ok, "abc"} = {:ok, "hello"}):
(term is unmatched with pattern, raise an runtime error)
For case using pattern in argument of function, if pattern is unmatched with argument, Elixir will check with next function. If no function is matched with the pattern, an runtime error will be raised.
Simple, we can check value of variables like:
a = :an_atom
b = 1_000
c = {:ok, 1}
# ...
# use case 1
:an_atom = a
1_000 = b
{:ok, 1} = c
# use case 2
case a do
:an_atom ->
:ok
_other ->
:nok
end
case b do
1_000 ->
:default
_ ->
:user_config
end
# use case 3
check_ok = fn
:ok -> true
_ -> false
end
result = check_ok.(a)
For case check equal value, that usually uses for verifying value, condition for branch code in function/case do.
If variable is complex term example a tuple, list, map. We can discard other values to check one or more values we want.
Example:
list = [1, :a, "hello"]
tuple = {:ok, :a, 1}
map = %{a: 1, b: "hello"}
# check first item of list is 1.
[1|_] = list # or ^list = [1|_]
# check tuple has same values.
copy = ^tuple = {:ok, :a, 1}
# check tuple has same number of elements.
{_, _, _} = tuple
# check map has a key = :a and value of key = 1.
%{a: 1} = map
Extracting value
This feature of pattern matching help us can extract one or more value from a complex term.
Remember, our expected value will bind to variable follow format of our pattern or key in map case.
(expression of pattern matching:
{:ok, get_value} = {:ok, "hello"}.
after matched, we got "hello" value from original term)
Example:
tuple = {:ok, "hello"}
list = [:a, :b, 1, 2]
complex = {:ok, [{:first, 1}, {:second, [1, 2, 3]}]}
# extract second element of tuple
{:ok, value} = tuple
# get first item in list
[firt|_] = list
# get second item in list
[_, second|_] = list
# get value of result
{:ok, [{_, first_value}, {:second, second_value}]} = complex
We can use all key of example for function like:
defmodule Example do
def process_second([_, second|_]) do
# do something with second item.
IO.puts("Value of second item: #{inspect second}")
second
end
def extract_map(%{a: value} = map) do
# do some thing with value & map.
IO.puts("key a has value = #{inspect value}")
value
end
end
# use cases for pattern matching in function arguments.
list = [1, :default, "hello"]
map = %{a: "hello", b: "world"}
Example.process_second(list)
Example.extract_map(map)
Other common cases for pattern matching with head of function are separating code like:
defmodule Exam do
def process_result({:error, reason}) do
# do something with error case.
end
def process_result({:ok, result}) do
# do something with result.
end
end
For multi patterns in one expression we can declare like:
list = {:ok, {:waiting, [1, 2, 3]}, {:running, [4, 5, 6]}}
{:ok, _, _} = {_, {:waiting, list1}, _} = {_, _, {:running, list2}} = list
# after run, list1 = [1, 2, 3], list2 = [4, 5, 6]
Pattern matching with Binary/Bitstring
This is interesting way to work with binary in Elixir. I wish other languages have this feature.
We have two type of raw data is binary (for work with byte) and bitstring (for work with bit).
Elixir has very convenient way to work with raw data like binary and bitstring. We can construct and matching these easily.
In this topic we just go to how to match a binary or bitstring only.
Binary matching
Example:
# each byte is an integer 8 bit.
bin = <<1, 2, 3, 4, 5>>
# Get first byte
<<first, rest::binary>> = bin
# Get second byte
<<1, second, rest::binary>> = bin
# get 2 bytes in head of binary
<<head::binary-size(2), rest::binary>> = bin
Is it simple right?
Bitstring matching
We can match & get single bit from a raw data (bitstring).
Example:
bit = <<3::4, 1::4, 3::4, 0::4>>
# get first 8 bits from bitstring.
<<first_4::bitstring-size(8), rest::bitstring>> = bit
# get 4 bits after first 4 bits is match to <<3::4>> and store to get_4_bits variable
<<3::4, get_4_bits::bitstring-size(4), _>> = bit
We can easy to process raw data with pattern matching.
Top comments (0)