Mix.install([
{:jason, "~> 1.4"},
{:kino, "~> 0.9", override: true},
{:youtube, github: "brooklinjazz/youtube"},
{:hidden_cell, github: "brooklinjazz/hidden_cell"}
])Upon completing this lesson, a student should understand:
- How to achieve polymorphism with multiple function heads and case statements.
- How to simplify our program's control-flow using polymorphism.
- How to use pattern matching with enumeration.
In functional programming, polymorphism refers to the ability of program to behave differently under different conditions.
There are many ways to achieve polymorphism in Elixir such as pattern matching, higher-order functions, and multi-clause functions.
In data-based polymorphism, a function can work with multiple types of inputs. For example, the Enum module is polymorphic, because it is data-agnostic and works on any enumerable data structure.
Pattern matching with the = coerces the left side of the operator to match the right side.
left = right
We can use this to match on values in the right side of the expression and bind them to variables.
{a, b} = {1, 2}In addition to binding values, we can use pattern matching to trigger functionality.
For example, when we use pattern matching with a case statement, we can trigger a different case clause depending on the shape of the data.
case {1, 2} -> do
[a, b] -> "behavior for list"
{a, b} -> "behavior for tuple"
end
See the previous reading material if you need a refresher on how to pattern match on each data type.
We can pattern match using the match operator.
{:ok, one} = {:ok, 1}We're able to use the match operator in more places than you might think. Anytime we have an Elixir term bound to a parameter or a variable we can use the = operator. This is useful for binding the entire parameter of a function while still using pattern matching to match on values within the parameter.
defmodule PatternParamExample do
def inspect([a, b, c] = param1) do
IO.inspect(a, label: "a")
IO.inspect(b, label: "b")
IO.inspect(c, label: "c")
IO.inspect(param1, label: "c")
end
end
PatternParamExample.inspect([1, 2, 3])Sometimes we use this pattern to validate that a particular parameter is the shape of data that we expect. For example, the following confirms the parameter in the function is a map.
defmodule MapsOnly do
def inspect(%{} = map) do
IO.inspect(map)
end
end
MapsOnly.inspect(%{})Any non-map data type would crash the function with a FunctionClauseError.
MapsOnly.inspect("this should crash")We can do the same inside of a case statement, or with other data types such as lists.
case [1, 2, 3] do
[head | tail] = list ->
IO.inspect(head, label: "head")
IO.inspect(tail, label: "tail")
IO.inspect(list, label: "list")
endWe can use the match operator anytime we have a value bound to a parameter or variable that we want to match on. Pattern matching can also be used with control flow to trigger application behavior based on if the pattern matches.
Create a case statement that will return the first element in a 2 element tuple, or the first element in a 2 element list.
Use pattern matching to ensure the Check.must_have_elements!/1 function returns true when called with a list that has more than one element and otherwise causes a FunctionClauseError.
Example Solution
defmodule Check do
def must_have_elements!([_head | _tail] = list) do
true
end
enddefmodule Check do
@doc """
Doubles a list
## Examples
iex> Check.must_have_elements!([1, 2, 3])
true
iex> Check.must_have_elements!([1])
true
iex> Check.must_have_elements!([])
** (FunctionClauseError) no function clause matching in Check.must_have_elements!/1
"""
def must_have_elements!(list) do
true
end
endWe can omit the = when pattern matching in a function.
defmodule Coords do
def inspect({x, y}) do
IO.inspect(x, label: "x axis")
IO.inspect(y, label: "y axis")
end
end
Coords.inspect({1, 2})We can use pattern matching with multi-clause functions. This essentially uses multi-clause functions to replicate the same behavior as a single function with a case statement.
defmodule SingleCaseExample do
def run(param) do
case param do
[] -> "1"
[_] -> "2"
[_, _] -> "3"
end
end
end
SingleCaseExample.run([]) |> IO.inspect(label: "first")
SingleCaseExample.run([1]) |> IO.inspect(label: "second")
SingleCaseExample.run([1, 1]) |> IO.inspect(label: "third")defmodule MultiClauseExample do
def run([]) do
"1"
end
def run([_]) do
"2"
end
def run([_, _]) do
"3"
end
end
MultiClauseExample.run([]) |> IO.inspect(label: "first")
MultiClauseExample.run([1]) |> IO.inspect(label: "second")
MultiClauseExample.run([1, 1]) |> IO.inspect(label: "third")This is often used for advanced control flow.
We can also pattern match in multiple function heads in an anonymous callback function.
anonymous_run = fn
[] -> "1"
[_] -> "2"
[_, _] -> "3"
end
anonymous_run.([]) |> IO.inspect(label: "first")
anonymous_run.([1]) |> IO.inspect(label: "second")
anonymous_run.([1, 1]) |> IO.inspect(label: "third")Use multi-clause functions to create a Greeter module which says different greetings based on what's provided as input to the hello/1 function.
defmodule Greeter do
@moduledoc """
Greeter
"""
@doc """
Return different greetings based on the number of elements in the list provided.
## Examples
iex> Greeter.hello(["Russel"])
"Hi Russel!"
iex> Greeter.hello(["Icia", "Stephen"])
"Hi Icia, Hello Stephen!"
iex> Greeter.hello(["Swamy", "Jeff", "Jeremy"])
"Hello everyone!"
"""
def hello(names) do
end
endWe can combine pattern matching in a function with enumeration to achieve polymorphic behavior with an enumerable data structure.
enumerable = [double: 1, double: 2, triple: 3, quadruple: 4]
Enum.map(enumerable, fn
{:double, value} -> value * 2
{:triple, value} -> value * 3
{:quadruple, value} -> value * 4
end)The same can be done with other Enum functions that accept a callback function such as Enum.filter/2 and Enum.reduce/3.
enumerable = [add: 1, subtract: 2, add: 4, multiply: 3]
Enum.reduce(enumerable, 0, fn
{:add, value}, acc -> acc + value
{:subtract, value}, acc -> acc - value
{:multiply, value}, acc -> acc * value
end)enumerable = [keep: 1, remove: 2, keep: 4, remove: 1]
Enum.filter(enumerable, fn
{:keep, _} -> true
{:remove, _} -> false
end)Use Enum.map/2 with pattern matching and multi-clause functions to double {:double, integer} tuples and divide (div) {:halve, integer} tuples in the following list.
[{:double, 2}, {:halve, 10}, {:double, 4}] -> [4, 5, 8]Example Solution
Enum.map([{:double, 2}, {:halve, 10}, {:double, 4}], fn
{:double, integer} -> integer * 2
{:halve, integer} -> div(integer, 2)
end)Often we have many tools to accomplish the same action. For example, let's say we're building an application where users send each other messages. However, only admin users are allowed to send messages.
Using if, we could write the following.
defmodule MessageIfExample do
def send(user, message) do
if user.is_admin do
message
else
{:error, :not_authorized}
end
end
endLet's say we also need to handle empty messages.
defmodule MessageNestedIfExample do
def send(user, message) do
if user.is_admin do
if message == "" do
{:error, :empty_message}
else
message
end
else
{:error, :not_authorized}
end
end
end
MessageNestedIfExample.send(%{is_admin: true}, "")Nested if statements are generally a clue that we should consider an alternative implementation.
Let's see how we could solve this problem with pattern matching.
defmodule MessageMatchExample do
def send(%{is_admin: true}, "") do
{:error, :empty_message}
end
def send(%{is_admin: true}, message) do
{:ok, message}
end
def send(%{is_admin: false}, _) do
{:error, :not_authorized}
end
endMessageMatchExample.send(%{is_admin: true}, "")MessageMatchExample.send(%{is_admin: false}, "Error!")MessageMatchExample.send(%{is_admin: true}, "Successful!")The pin operator allows us to use variables as hard-coded values, rather than rebinding a variable.
Often we use the pin operator when testing our code to assert that the value is correct.
For example, the following will rebind the received variable to [1, 2, 3].
received = [1, 2]
expected = [1, 2, 3]
received = expectedBut instead, we might use the match operator to check that the received value matches the expected value.
received = [1, 2]
expected = [1, 2, 3]
^received = expectedBy using the pin operator above, we accomplish the same as if we had written:
[1, 2] = [1, 2, 3]We can also use this for internal values in a collection. The following is the same
as [1, 2, 3] = [2, 2, 3]
first = 1
actual = [2, 2, 3]
[^first, 2, 3] = actualAnd the following is the same as [1, 2, 3] = [1, 2, 3]
first = 1
actual = [1, 2, 3]
[^first, 2, 3] = actualWe'll also use the pin operator when triggering control flow with pattern matching. For example, we might use it in a case statement.
pinned_value = 1
case {:ok, 1} do
{:ok, ^pinned_value} -> "clause 1"
{:ok, generic_value} -> "clause 2"
endIf we don't pin the value, the bound variable will be treated as though we were re-binding the variable, and the first case clause will always match.
pinned_value = 1
# Despite Being 2, Not 1, Clause 1 Is Triggered Because We Didn't Pin The Value.
case {:ok, 2} do
{:ok, pinned_value} -> "clause 1"
{:ok, generic_value} -> "clause 2"
endUse the pin operator to make the following code crash with a MatchError because expected does not match actual, rather than rebinding expected as it is currently doing.
Example Solution
expected = {"hello"}
actual = {"hello", "hi"}
^expected = actualexpected = {"hello"}
actual = {"hello", "hi"}
expected = actualConsider the following resource(s) to deepen your understanding of the topic.
- Elixir Schools: Pattern Matching
- Exercism.io: Pattern Matching
- elixir-lang.org: Pattern Matching
- HexDocs: Patterns and Guards
DockYard Academy now recommends you use the latest Release rather than forking or cloning our repository.
Run git status to ensure there are no undesirable changes.
Then run the following in your command line from the curriculum folder to commit your progress.
$ git add .
$ git commit -m "finish Advanced Pattern Matching reading"
$ git push
We're proud to offer our open-source curriculum free of charge for anyone to learn from at their own pace.
We also offer a paid course where you can learn from an instructor alongside a cohort of your peers. We will accept applications for the June-August 2023 cohort soon.