Question regarding pattern matching functions based on input type

Questions / Help
,
1

I understand pattern matching in a very basic sense.

So for example I understand perfectly well what this code does

%{william: age} = %{william: 40 }

IO.inspect age # 40

{a, b} = {100, 200}

IO.inspect a # 100

IO.inspect b # 200

What I am having trouble understanding is function behavior when named functions with the same name and arity take precedence over one another based on argument type

So for example, the following code is an implementation of a len function and it returns the length of a list. For the most part I understand how it works ( I think ). The two functions allow for behavior usually reserved for conditional statements. If the array is empty then the recursion is terminated

defmodule Mylist do
def len(), do: 0
def len([head|tail]), do: 1 + len(tail)
end

IO.inspect Mylist.len([5, 4, 3, 2, 1]) # 5

The previous functions only work if the argument type is a list. If I did the following I get an error:

IO.inspect Mylist.len(“blah”) # no function clause matching in Mylist.len/1

Based on this, I assume there is a way to write functions that only respond to inputs that are of type number or string. Is this possible without using conditional statements?

2

It possible to do using guard clause e.g.
def blah(a) when is_integer(a) , do: a
https://hexdocs.pm/elixir/master/guards.html

1 Like
3

Cool, thanks. I read about guard clauses but didn’t think to use them. I’m trying to learn to “think” like an Elixir dev

1 Like
4

You can also match on the string type (binary) itself. :slight_smile:

def takes_only_string(<<the_string::binary>>), do: the_string

For integers, like andre1sk’s example, a guard clause is required (and there are guard clauses for is_binary/1 too). :slight_smile:

1 Like
5

And if you want to go further, let’s pattern match on the content of the string itself:

def strip_prefix("prefix" <> rest), do: rest

strip_prefix("foo") # FunctionClauseError
strip_prefix("prefixfoo") # => foo

But note that you can’t do this:

def strip_suffix(rest <> "suffix"), do: rest
# CompileError, a binary field without size is only allowed at the end of a binary pattern

You must specify the size:

def strip_suffix(<<rest::binary-size(4)>> <> "suffix"), do: rest

strip_suffix("foo") # FunctionClauseError
strip_suffix("foosuffix") # FunctionClauseError
strip_suffix("fooosuffix") # => fooo
2 Likes