Part- 3

elixir-tips
Search…
Killer Elixir-Tips
Part- 1
Part- 3
1. Functions as Guard Clauses
We cannot make use of the functions as guard clauses in elixir. It means, when cannot accept functions that returns Boolean values as conditions. Consider the following lines of code…
1
defmodule Hello do
2
  def hello(name, age) when is_kid(age) do
3
    IO.puts "Hello Kid #{name}"
4
  end
5
  def hello(name, age) when is_adult(age) do
6
    IO.puts "Hello Mister #{name}"
7
  end
8
  def is_kid age do
9
    age < 12
10
  end
11
  def is_adult age do
12
    age > 18
13
  end
14
end
Copied!
Here we defined a module Hello and a function hello that takes two parameters of name and age. So, based on age I am trying IO.putsaccordingly. If you do so you will get an error saying….
1
** (CompileError) hello.ex:2: cannot invoke local is_kid/1 inside guard
2
    hello.ex:2: (module)
Copied!
This is because when cannot accept functions as guards. We need to convert them to macros Lets do that…
1
defmodule MyGuards do
2
​
3
  defmacro is_kid age do
4
    quote do: unquote(age) < 12
5
  end
6
​
7
  defmacro is_adult age do
8
    quote do: unquote(age) > 18
9
  end
10
​
11
end
12
# order of module matters here.....
13
defmodule Hello do
14
​
15
  import MyGuards
16
​
17
  def hello(name, age) when is_kid(age) do
18
    IO.puts "Hello Kid #{name}"
19
  end
20
​
21
  def hello(name, age) when is_adult(age) do
22
    IO.puts "Hello Mister #{name}"
23
  end
24
​
25
  def hello(name, age) do
26
    IO.puts "Hello Youth #{name}"
27
  end
28
​
29
end
Copied!
In the above lines of code, we wrapped all our guards inside a module MyGuards and make sure the module is top of the module Hello so, the macros first gets compiled. Now compile and execute you will see the following output..
1
iex> Hello.hello "blackode", 21
2
Hello Mister blackode
3
:ok
4
iex> Hello.hello "blackode", 11
5
Hello Kid blackode
6
:ok
Copied!
Starting on Elixir v1.6, you can use defguard/1.
The defguard is also a macro. You can also create private guards with defguardp. Hope, you got the point here.
Consider the following example.
NOTE: The defguard and defguardp should reside inside the module like other macros. It raises a compile time error, if some thing that don't fit in the guard clause section when.
Suppose, you want to check the given number is either three or five, you can define the guard as following.
1
defmodule Number.Guards do
2
  defguard is_three_or_five(number) when (number===3) or (number===5)
3
end
Copied!
Usage
1
import Number.Guards
2
defmodule Hello do
3
  def check_favorite_number(num) when is_three_or_five(num) do
4
    IO.puts "The given #{num} is on of my favourite numbers"
5
  end
6
  def check_favorite_number(_num), do: IO.puts "Not my favorite number"
7
end
Copied!
You can also use them inside your code logic as they results boolean value.
1
iex> import Number.Guards
2
Number.Guards
3
​
4
iex> is_three_or_five(5)
5
true
6
​
7
iex> is_three_or_five(3)
8
true
9
​
10
iex> is_three_or_five(1)
11
false
Copied!
Check the following execution screen shot.
ScreenShot Defguard Execution
2. Finding the presence of Sub-String
Using =~ operator we can find whether the right sub-string present in left string or not..
1
iex> "blackode" =~ "kode" 
2
true  
3
iex> "blackode" =~ "medium" 
4
false  
5
iex> "blackode" =~ "" 
6
true
Copied!
3. Finding whether Module is loaded or not
Sometimes, we have to make sure that certain module is loaded before making a call to the function. We are supposed to ensure the module is loaded.
1
Code.ensure_loaded? <Module>
Copied!
1
iex> Code.ensure_loaded? :kernel
2
true
3
iex> Code.ensure_loaded :kernel
4
{:module, :kernel}
Copied!
Similarly we are having ensure_compile to check whether the module is compiled or not…
4. Binary to Capital Atom
Elixir provides a special syntax which is usually used for module names. What is called a module name is an uppercase ASCII letter followed by any number of lowercase or uppercase ASCII letters, numbers, or underscores.
This identifier is equivalent to an atom prefixed by Elixir. So in the defmodule Blackode example Blackode is equivalent to :"Elixir.Blackode"
When we use String.to_atom "Blackode" it converts it into :Blackode But actually we need something like “Blackode” to Blackode. To do that we need to use Module.concat
1
iex(2)> String.to_atom "Blackode"
2
:Blackode
3
iex(3)> Module.concat Elixir,"Blackode"
4
Blackode
Copied!
In Command line applications whatever you pass they convert it into binary. So, again you suppose to do some casting operations …
5. Pattern match [ vs ] destructure.
We all know that = does the pattern match for left and right side. We cannot do [a, b, c] = [1, 2, 3, 4] this raise a MatchError
1
iex(11)> [a, b, c] = [1, 2, 3, 4]
2
** (MatchError) no match of right hand side value: [1, 2, 3, 4]
Copied!
We can use destructure/2 to do the job.
1
iex(1)> destructure [a, b, c], [1, 2, 3, 4]
2
[1, 2, 3]
3
iex(2)> {a, b, c}
4
{1, 2, 3}
Copied!
If the left side is having more entries than in right side, it assigns the nil value for remaining entries..
1
iex> destructure([a, b, c], [1])
2
iex> {a, b, c} 
3
{1, nil, nil}
Copied!
6. Data decoration [ inspect with :label ] option
We can decorate our output with inspect and label option. The string of label is added at the beginning of the data we are inspecting.
1
iex(1)> IO.inspect [1, 2, 3], label: "the list "
2
the list : [1, 2, 3]
3
[1, 2, 3]
Copied!
If you closely observe this it again returns the inspected data. So, we can use them as intermediate results in |> pipe operations like following……
1
[1, 2, 3] 
2
|> IO.inspect(label: "before change") 
3
|> Enum.map(&(&1 * 2)) 
4
|> IO.inspect(label: "after change") 
5
|> length
Copied!
You will see the following output
1
before change: [1, 2, 3]
2
after change: [2, 4, 6]
3
3
Copied!
7. Anonymous functions to pipe
We can pass the anonymous functions in two ways. One is directly using &like following..
1
[1, 2, 3, 4, 5]
2
|> length()
3
|> (&(&1*&1)).()
Copied!
This is the most weirdest approach. How ever, we can use the reference of the anonymous function by giving its name.
1
square = & &1 * &1
2
[1, 2, 3, 4, 5]
3
|> length()
4
|> square.()
Copied!
The above style is much better than previous . You can also use fn to define anonymous functions.
8. Retrieve Character Integer Codepoints — ?
We can use ? operator to retrieve character integer codepoints.
1
iex> ?a
2
97
3
iex> ?#
4
35
Copied!
The following two tips are mostly useful for beginners…
9. Subtraction over Lists
We can perform the subtraction over lists for removing the elements in list.
1
iex> [1, 2, 3, 4.5] -- [1, 2]
2
[3, 4.5]
3
iex> [1, 2, 3, 4.5, 1] -- [1]  
4
[2, 3, 4.5, 1]
5
iex> [1, 2, 3, 4.5, 1] -- [1, 1]
6
[2, 3, 4.5]
7
iex> [1, 2, 3, 4.5] -- [6]
8
[1, 2, 3, 4.5]
Copied!
We can also perform same operations on char lists too..
1
iex(12)> 'blackode' -- 'ode'
2
'black'
3
iex(13)> 'blackode' -- 'z'    
4
'blackode'
Copied!
If the element to subtract is not present in the list then it simply returns the list.
10. Using Previous results in IEx
When you are working with iex environment , you can see a number increment every time you evaluate an expression in the shell like iex(2)> iex(3)>
Those numbers helps us to reuse the result with v/1 function which has been loaded by default..
1
iex(1)> list = [1, 2, 3, 4, 5]
2
[1, 2, 3, 4, 5]
3
iex(2)> double_list = Enum.map(list, &(&1*2))
4
[2, 4, 6, 8, 10]
5
iex(3)> v 1
6
[1, 2, 3, 4, 5]
7
iex(4)> v(1) ++ v(2)
8
[1, 2, 3, 4, 5, 2, 4, 6, 8, 10]
Copied!
​Prev Next​
Part- 2
Part- 4
Last modified 2yr ago
Copy link
Contents
1. Functions as Guard Clauses
Usage
2. Finding the presence of Sub-String
3. Finding whether Module is loaded or not
4. Binary to Capital Atom
5. Pattern match [ vs ] destructure.
6. Data decoration [ inspect with :label ] option
7. Anonymous functions to pipe
8. Retrieve Character Integer Codepoints — ?
9. Subtraction over Lists
10. Using Previous results in IEx