ELIXIR TUTORIAL
BASIC TYPES
Interactive Elixir (iex)
Type iex in the command line to enter the shell for Erlang /OTP environment.
FOUR TYPES
Atoms
Strings
Tuples
Lists
Maps
Elixir have two file types;
.exs: are intended for scripting and they stay in memory when run or executed.
.ex: are compiled to byte code and written to disk in a beam file.
ATOMS
It is a constant where its name is a value. Atoms are memory efficient.
Example:
C:\Users\essie>iex
Interactive Elixir (1.5.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> :firstname
:firstname
iex(2)> :"this is also atom"
:"this is also atom"
iex(3)> IO.puts(:"this is also atom")
this is also atom
:ok
iex(4)>
Atoms have returning values:
{:ok, content}
{:error, reason}
Atoms have Boolean
:true
:false
Example:
Inspect the Boolean true and false.
iex(7)> i false
Term
false
Data type
Atom
Reference modules
Atom
iex(4)> i true
Term
true
Data type
Atom
Reference modules
Atom
STRINGS
Format “sting_name”
Example:
iex(1)> euro = "#"
"#"
iex(2)> byte_size(euro)
iex(3)> String.length(euro)
iex(4)> name = "Hello, "
"Hello, "
iex(5)> hello = "Nana"
"Nana"
iex(6)> name <> hello
"Hello, Nana"
<>: concatenation
Example:
iex(7)> handle = "nana_yaw"
"nana_yaw"
iex(8)> "My tweeter handle is @#{handle}. Feel free to send a message."
"My tweeter handle is @nana_yaw. Feel free to send a message."
TUPLES
An ordered collection used for storing a peace of data, is use for two, three or four values.
Format: {“items”, ”items”}
Example:
iex(1)> book={"Programming Book", "Dave", 25.00}
{"Programming Book", "Dave", 25.0}
iex(2)> elem(book, 2)
25.0
iex(3)> put_elem(book, 2, 49.00)
{"Programming Book", "Dave", 49.0}
iex(4)> book
{"Programming Book", "Dave", 25.0}
LISTS
Lists is used for storing much more data
Elixir list is Single-Linked List
Format: [listitem, “listitem2”]
Example:
Interactive Elixir (1.5.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> first_list = [1,2,3]
[1, 2, 3]
iex(2)> second_list = [:ok, 1, "test", first_list]
[:ok, 1, "test", [1, 2, 3]]
iex(3)> hd(first_list)
1
iex(4)> tl(first_list)
[2, 3]
iex(5)> third_list = [1 | [2,3]]
[1, 2, 3]
iex(6)> fourth_list = [1 | [2 | [3 | []]]]
[1, 2, 3]
iex(7)> [:ok | first_list]
[:ok, 1, 2, 3]
iex(8)> [a,b,c] = first_list
[1, 2, 3]
iex(9)> a
iex(10)> b
iex(11)> c
iex(12)> [head | tail ] = first_list
[1, 2, 3]
iex(13)> head
iex(14)> tail
[2, 3]
iex(15)> options = [{:is_active, false}, {:notify_user, true}, {:created_if_not_exists, true}]
[is_active: false, notify_user: true, created_if_not_exists: true]
iex(16)> options[:notify_user]
true
IMMUTABILITY
In elixir, data is immutable, meaning that if the data is created, it cannot change.
Example:
Interactive Elixir (1.5.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> languages = ["Java", "PHP", "C"]
["Java", "PHP", "C"]
iex(2)> List.insert_at(languages, 0, "C++")
["C++", "Java", "PHP", "C"]
IMMUTABILITY BENEFITS
1. It provides concurrency of immutable data
2. It reuses memory
MAPS
Are collections of key value pairs.
Format: %{key => {“mapitem”}}
Similarities of lists and maps are collections of items that have a key and a value.
Differences
MAPS: the key does not have to an atom; it can be any type. It only allows one instance of each key.
MAPS are more efficient that Lists.
Keyword Lists don’t have that constraints
Example
iex(1)> my_map = %{1 => {"Nana", "Yaw"}, 2 => {"Mark", "Annafi"}}
%{1 => {"Nana", "Yaw"}, 2 => {"Mark", "Annafi"}}
iex(2)> other_map = %{:names => ["Nana Yaw", "Mark Annafi"], "gender"=> "male"}
%{:names => ["Nana Yaw", "Mark Annafi"], "gender" => "male"}
iex(3)> another_map = %{{:ok, 1} => true, {:ok, 2} =>false}
%{{:ok, 1} => true, {:ok, 2} => false}
iex(4)> other_map["gender"]
"male"
iex(5)> other_map.names
["Nana Yaw", "Mark Annafi"]
iex(6)> %{:names => names_lists} = other_map
%{:names => ["Nana Yaw", "Mark Annafi"], "gender" => "male"}
iex(7)> names_lists
["Nana Yaw", "Mark Annafi"]
MODULES AND FUNCTIONS
MODULES
Modules have 3 purpose;
They serve to annotate the module, often with information to be used by the user or
the VM.
They work as constants.
They work as a temporary module storage to be used during compilation.
Example:
Coding the .exs file;
defmodule ModulePlaygroup do
def say_hello do
IO.puts "Hello World Elixir"
end
end
Compile in terminal
C:\Users\essie\Desktop>iex "module_playgroup.exs"
Interactive Elixir (1.5.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> ModulePlaygroup.say_hello
Hello World
:ok
iex(2)> r(ModulePlaygroup)
warning: redefining module ModulePlaygroup (current version defined in memory)
module_playgroup.exs:1
{:reloaded, ModulePlaygroup, [ModulePlaygroup]}
iex(3)> ModulePlaygroup.say_hello
Hello World Elixir
:ok
MODULES DIRECTIVES
1. IMPORT: Include module functions. Includes/Excludes specific functions from specific modules
Example:
Coding the .exs file;
defmodule ModulePlaygroup do
import IO, only: [puts: 1]
import Kernel, except: [inspect: 1]
def say_hello do
inspect "Hello World Elixir"
end
def inspect(param1) do
puts "Starting Output"
puts param1
puts "Ending output"
end
end
Compile in terminal
iex(2)> r(ModulePlaygroup)
warning: redefining module ModulePlaygroup (current version defined in memory)
module_playgroup.exs:1
{:reloaded, ModulePlaygroup, [ModulePlaygroup]}
iex(3)> ModulePlaygroup.say_hello
Starting Output
Hello World Elixir
Ending output
:ok
2. ALIAS: Reduce typing module names. Renaming modules in your modules
Example:
Coding the .exs file;
defmodule ModulePlaygroup do
import IO, only: [puts: 1]
import Kernel, except: [inspect: 1]
alias ModulePlaygroup.Misc.Util.Math, as: MyMath
def say_hello do
inspect "Hello World Elixir"
end
def inspect(param1) do
puts "Starting Output"
puts param1
puts "Ending output"
end
def print_sum do
MyMath.add(1,2)
end
end
defmodule ModulePlaygroup.Misc.Util.Math do
def add(a,b) do
a+b
end
end
Compile in Terminal
iex "module_playgroup.exs"
Interactive Elixir (1.5.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> import_file("misc_util_maths.exs")
{:module, ModulePlaygroup.Misc.Util.Math,
<<70, 79, 82, 49, 0, 0, 3, 200, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 109,
0, 0, 0, 9, 37, 69, 108, 105, 120, 105, 114, 46, 77, 111, 100, 117, 108, 101,
80, 108, 97, 121, 103, 114, 111, 117, 112, ...>>, {:add, 2}}
iex(2)> ModulePlaygroup.print_sum
iex(3)> r(ModulePlaygroup)
warning: redefining module ModulePlaygroup (current version defined in memory)
module_playgroup.exs:1
{:reloaded, ModulePlaygroup, [ModulePlaygroup]}
iex(4)> ModulePlaygroup.print_sum
3
3. REQUIRE: Allows using macros in your module that will depend upon.
Example:
Coding the .exs file
defmodule ModulePlaygroup do
import IO, only: [puts: 1]
import Kernel, except: [inspect: 1]
alias ModulePlaygroup.Misc.Util.Math, as: MyMath
require Integer
def say_hello do
inspect "Hello World Elixir"
end
def inspect(param1) do
puts "Starting Output"
puts param1
puts "Ending output"
end
def print_sum do
MyMath.add(1,2)
end
def is_even(num) do
puts "Is #{num} even? #{Integer.is_even(num)}"
end
end
defmodule ModulePlaygroup.Misc.Util.Math do
def add(a,b) do
a+b
end
end
Compile in Terminal
iex(5)> r(ModulePlaygroup)
warning: redefining module ModulePlaygroup (current version defined in memory)
module_playgroup.exs:1
{:reloaded, ModulePlaygroup, [ModulePlaygroup]}
iex(6)> ModulePlaygroup.is_even(1)
Is 1 even? false
:ok
iex(7)> ModulePlaygroup.is_even(2)
Is 2 even? true
:ok
iex(8)> ModulePlaygroup.is_even(4)
Is 4 even? true
:ok
iex(9)>
