Hugging Face's logo

Datasets:
Vikhrmodels
/
programming_books_eng

Modalities:
Text
Formats:
text
Size:
1M - 10M
Libraries:
Datasets
License:
Dataset card Data Studio Files
xet
 Community
programming_books_eng / Elixir /elixir-language.pdf.txt
apsys's picture
apsys
Upload folder using huggingface_hub
08c8a6d verified
raw
history blame contribute delete
96.8 kB
Elixir Language
#elixir
Table of Contents
About
Chapter 1: Getting started with Elixir Language
Remarks
Versions
Examples
Hello World
Hello World from IEx
Chapter 2: Basic .gitignore for elixir program
Chapter 3: Basic .gitignore for elixir program
Remarks
Examples
A basic .gitignore for Elixir
Example
Standalone elixir application
Phoenix application
Auto-generated .gitignore
Chapter 4: basic use of guard clauses
Examples
basic uses of guard clauses
Chapter 5: BEAM
Examples
Introduction
Chapter 6: Behaviours
Examples
Introduction
Chapter 7: Better debugging with IO.inspect and labels
Introduction
Remarks
Examples
Without labels
1
2
2
2
2
2
3
5
6
6
6
6
6
6
7
7
8
8
8
10
10
10
11
11
11
12
12
12
12
12
With labels
Chapter 8: Built-in types
Examples
Numbers
Atoms
Binaries and Bitstrings
Chapter 9: Conditionals
Remarks
Examples
case
if and unless
cond
with clause
Chapter 10: Constants
Remarks
Examples
Module-scoped constants
Constants as functions
Constants via macros
Chapter 11: Data Structures
Syntax
Remarks
Examples
Lists
Tuples
Chapter 12: Debugging Tips
Examples
Debugging with IEX.pry/0
Debugging with IO.inspect/1
Debug in pipe
Pry in pipe
Chapter 13: Doctests
13
14
14
14
15
15
17
17
17
17
17
18
18
20
20
20
20
20
21
23
23
23
23
23
23
24
24
24
24
25
25
27
Examples
Introduction
Generating HTML documentation based on doctest
Multiline doctests
Chapter 14: Ecto
Examples
Adding a Ecto.Repo in an elixir program
"and" clause in a Repo.get_by/3
Querying with dynamic fields
Add custom data types to migration and to schema
Chapter 15: Erlang
Examples
Using Erlang
Inspect an Erlang module
Chapter 16: ExDoc
Examples
Introduction
Chapter 17: ExUnit
Examples
Asserting Exceptions
Chapter 18: Functional programming in Elixir
Introduction
Examples
Map
Reduce
Chapter 19: Functions
Examples
Anonymous Functions
Using the capture operator
Multiple bodies
Keyword lists as function parameters
27
27
27
27
29
29
29
29
30
30
31
31
31
31
32
32
32
33
33
33
34
34
34
34
34
36
36
36
36
37
37
Named Functions & Private Functions
Pattern Matching
Guard clauses
Default Parameters
Capture functions
Chapter 20: Getting help in IEx console
Introduction
Examples
Listing Elixir modules and functions
Chapter 21: IEx Console Tips & Tricks
Examples
Recompile project with `recompile`
See documentation with `h`
Get value from last command with `v`
Get the value of a previous command with `v`
Exit IEx console
See information with `i`
Creating PID
Have your aliases ready when you start IEx
Persistent history
When Elixir console is stuck...
break out of incomplete expression
Load a module or script into the IEx session
Chapter 22: Installation
Examples
Fedora Installation
OSX Installation
Homebrew
Macports
Debian/Ubuntu Installation
Gentoo/Funtoo Installation
Chapter 23: Join Strings
37
38
38
39
39
41
41
41
41
42
42
42
42
42
42
43
43
44
44
44
44
45
46
47
47
47
47
47
47
47
47
49
Examples
Using String Interpolation
Using IO List
Using Enum.join
Chapter 24: Lists
Syntax
Examples
Keyword Lists
Char Lists
Cons Cells
Mapping Lists
List Comprehensions
Combined example
Summary
List difference
List Membership
Converting Lists to a Map
Chapter 25: Maps and Keyword Lists
Syntax
Remarks
Examples
Creating a Map
Creating a Keyword List
Difference between Maps and Keyword Lists
Chapter 26: Metaprogramming
Examples
Generate tests at compile time
Chapter 27: Mix
Examples
Create a Custom Mix Task
Custom mix task with command line arguments
Aliases
49
49
49
49
50
50
50
50
51
52
52
53
53
53
54
54
54
55
55
55
55
55
55
56
57
57
57
58
58
58
58
58
Get help on available mix tasks
Chapter 28: Modules
Remarks
Module Names
Examples
List a module's functions or macros
Using modules
Delegating functions to another module
Chapter 29: Nodes
Examples
List all visible nodes in the system
Connecting nodes on the same machine
Connecting nodes on different machines
Chapter 30: Operators
Examples
The Pipe Operator
Pipe operator and parentheses
Boolean operators
Comparison operators
Join operators
'In' operator
Chapter 31: Optimization
Examples
Always measure first!
Chapter 32: Pattern matching
Examples
Pattern matching functions
Pattern matching on a map
Pattern matching on a list
Get the sum of a list using pattern matching
Anonymous functions
Tuples
59
60
60
60
60
60
60
61
62
62
62
62
62
64
64
64
64
65
66
66
67
68
68
68
69
69
69
69
69
70
70
71
Reading a File
Pattern matching anonymous functions
Chapter 33: Polymorphism in Elixir
Introduction
Remarks
Examples
Polymorphism with Protocols
Chapter 34: Processes
Examples
Spawning a Simple Process
Sending and Receiving Messages
Recursion and Receive
Chapter 35: Protocols
Remarks
Examples
Introduction
Chapter 36: Sigils
Examples
Build a list of strings
Build a list of atoms
Custom sigils
Chapter 37: State Handling in Elixir
Examples
Managing a piece of state with an Agent
Chapter 38: Stream
Remarks
Examples
Chaining multiple operations
Chapter 39: Strings
Remarks
Examples
71
71
73
73
73
73
73
75
75
75
75
75
77
77
77
77
78
78
78
78
78
79
79
79
80
80
80
80
81
81
81
Convert to string
Get a substring
Split a string
String Interpolation
Check if String contains Substring
Join Strings
Chapter 40: Task
Syntax
Parameters
Examples
Doing work in the background
Parallel processing
Chapter 41: Tips and Tricks
Introduction
Examples
Creating Custom Sigils and Documenting
Multiple [ OR ]
iex Custom Configuration - iex Decoration
Credits
81
81
81
81
81
82
83
83
83
83
83
83
84
84
84
84
84
84
86
About
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: elixir-language
It is an unofficial and free Elixir Language ebook created for educational purposes. All the content
is extracted from Stack Overflow Documentation, which is written by many hardworking individuals
at Stack Overflow. It is neither affiliated with Stack Overflow nor official Elixir Language.
The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.
Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@zzzprojects.com
https://riptutorial.com/
1
Chapter 1: Getting started with Elixir
Language
Remarks
Elixir is a dynamic, functional language designed for building scalable and maintainable
applications.
Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant
systems, while also being successfully used in web development and the embedded software
domain.
Versions
Version Release Date
0.9
1.0
1.1
1.2
1.3
1.4
2013-05-23
2014-09-18
2015-09-28
2016-01-03
2016-06-21
2017-01-05
Examples
Hello World
For installation instructions on elixir check here, it describes instructions related to different
platforms.
Elixir is a programming language that is created using erlang, and uses erlang's BEAM runtime (like
JVM for java).
We can use elixir in two modes: interactive shell iex or directly running using elixir command.
Place the following in a file named hello.exs:
IO.puts "Hello world!"
https://riptutorial.com/
2
From the command line, type the following command to execute the Elixir source file:
$ elixir hello.exs
This should output:
Hello world!
This is known as the scripted mode of Elixir. In fact, Elixir programs can also be compiled (and
generally, they are) into bytecode for the BEAM virtual machine.
You can also use iex for interactive elixir shell (recommended), run the command you will get a
prompt like this:
Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>
Here you can try your elixir hello world examples:
iex(1)> IO.puts "hello, world"
hello, world
:ok
iex(2)>
You can also compile and run your modules through iex. For example, if you have a helloworld.ex
that contains:
defmodule Hello do
def sample do
IO.puts "Hello World!"
end
end
Through iex, do:
iex(1)> c("helloworld.ex")
[Hello]
iex(2)> Hello.sample
Hello World!
Hello World from IEx
You can also use the IEx (Interactive Elixir) shell to evaluate expressions and execute code.
If you are on Linux or Mac, just type iex on your bash and press enter:
$ iex
If you are on a Windows machine, type:
https://riptutorial.com/
3
C:\ iex.bat
Then you will enter into the IEx REPL (Read, Evaluate, Print, Loop), and you can just type
something like:
iex(1)> "Hello World"
"Hello World"
If you want to load a script while opening an IEx REPL, you can do this:
$ iex script.exs
Given script.exs is your script. You can now call functions from the script in the console.
Read Getting started with Elixir Language online: https://riptutorial.com/elixir/topic/954/getting-
started-with-elixir-language
https://riptutorial.com/
4
Chapter 2: Basic .gitignore for elixir program
Read Basic .gitignore for elixir program online: https://riptutorial.com/elixir/topic/6493/basic--
gitignore-for-elixir-program
https://riptutorial.com/
5
Chapter 3: Basic .gitignore for elixir program
Remarks
Note that the /rel folder may not be needed in your .gitignore file. This is generated if you are
using a release management tool such as exrm
Examples
A basic .gitignore for Elixir
/_build
/cover
/deps
erl_crash.dump
*.ez
# Common additions for various operating systems:
# MacOS
.DS_Store
# Common additions for various editors:
# JetBrains IDEA, IntelliJ, PyCharm, RubyMine etc.
.idea
Example
### Elixir ###
/_build
/cover
/deps
erl_crash.dump
*.ez
### Erlang ###
.eunit
deps
*.beam
*.plt
ebin
rel/example_project
.concrete/DEV_MODE
.rebar
Standalone elixir application
/_build
/cover
/deps
erl_crash.dump
*.ez
https://riptutorial.com/
6
/rel
Phoenix application
/_build
/db
/deps
/*.ez
erl_crash.dump
/node_modules
/priv/static/
/config/prod.secret.exs
/rel
Auto-generated .gitignore
By default, mix new <projectname> will generate a .gitignore file in the project root that is suitable
for Elixir.
# The directory Mix will write compiled artifacts to.
/_build
# If you run "mix test --cover", coverage assets end up here.
/cover
# The directory Mix downloads your dependencies sources to.
/deps
# Where 3rd-party dependencies like ExDoc output generated docs.
/doc
# If the VM crashes, it generates a dump, let's ignore it too.
erl_crash.dump
# Also ignore archive artifacts (built via "mix archive.build").
*.ez
Read Basic .gitignore for elixir program online: https://riptutorial.com/elixir/topic/6526/basic--
gitignore-for-elixir-program
https://riptutorial.com/
7
Chapter 4: basic use of guard clauses
Examples
basic uses of guard clauses
In Elixir, one can create multiple implementations of a function with the same name, and specify
rules which will be applied to the parameters of the function before calling the function in order to
determine which implementation to run.
These rules are marked by the keyword when, and they go between the def function_name(params)
and the do in the function definition. A trivial example:
defmodule Math do
def is_even(num) when num === 1 do
false
end
def is_even(num) when num === 2 do
true
end
def is_odd(num) when num === 1 do
true
end
def is_odd(num) when num === 2 do
false
end
end
Say I run Math.is_even(2) with this example. There are two implementations of is_even, with
differing guard clauses. The system will look at them in order, and run the first implementation
where the parameters satisfy the guard clause. The first one specifies that num === 1 which is not
true, so it moves on to the next one. The second one specifies that num === 2, which is true, so this
is the implementation that is used, and the return value will be true.
What if I run Math.is_odd(1)? The system looks at the first implementation, and sees that since num
is 1 the guard clause of the first implementation is satisfied. It will then use that implementation
and return true, and not bother looking at any other implementations.
Guards are limited in the types of operations they can run. The Elixir documentation lists every
allowed operation; in a nutshell they allow comparisons, math, binary operations, type-checking
(e.g. is_atom), and a handful of small convenience functions (e.g. length). It is possible to define
custom guard clauses, but it requires creating macros and is best left for a more advanced guide.
Note that guards do not throw errors; they are treated as normal failures of the guard clause, and
the system moves on to look at the next implementation. If you find that you're getting
(FunctionClauseError) no function clause matching when calling a guarded function with params
https://riptutorial.com/
8
you expect to work, it may be that a guard clause which you expect to work is throwing an error
which is being swallowed up.
To see this for yourself, create and then call a function with a guard which makes no sense, such
as this which tries to divide by zero:
defmodule BadMath do
def divide(a) when a / 0 === :foo do
:bar
end
end
Calling BadMath.divide("anything") will provide the somewhat-unhelpful error (FunctionClauseError)
no function clause matching in BadMath.divide/1 — whereas if you had tried to run "anything" / 0
directly, you would get a more helpful error: (ArithmeticError) bad argument in arithmetic
expression.
Read basic use of guard clauses online: https://riptutorial.com/elixir/topic/6121/basic-use-of-guard-
clauses
https://riptutorial.com/
9
Chapter 5: BEAM
Examples
Introduction
iex> :observer.start
:ok
:observer.start opens the GUI observer interface, showing you CPU breakdown, memory usage,
and other information critical to understanding the usage patterns of your applications.
Read BEAM online: https://riptutorial.com/elixir/topic/3587/beam
https://riptutorial.com/
10
Chapter 6: Behaviours
Examples
Introduction
Behaviours are a list of functions specifications that another module can implement. They are
similar to interfaces in other languages.
Here’s an example behaviour:
defmodule Parser do
@callback parse(String.t) :: any
@callback extensions() :: [String.t]
end
And a module that implements it:
defmodule JSONParser do
@behaviour Parser
def parse(str), do: # ... parse JSON
def extensions, do: ["json"]
end
The @behaviour module attribute above indicates that this module is expected to define every
function defined in the Parser module. Missing functions will result in undefined behaviour function
compilation errors.
Modules can have multiple @behaviour attributes.
Read Behaviours online: https://riptutorial.com/elixir/topic/3558/behaviours
https://riptutorial.com/
11
Chapter 7: Better debugging with IO.inspect
and labels
Introduction
IO.inspect is very useful when you try to debug your chains of method calling. It can get messy
though if you use it too often.
Since Elixir 1.4.0 the label option of IO.inspect can help
Remarks
Only works with Elixir 1.4+, but I can't tag that yet.
Examples
Without labels
url
|> IO.inspect
|> HTTPoison.get!
|> IO.inspect
|> Map.get(:body)
|> IO.inspect
|> Poison.decode!
|> IO.inspect
This will result in a lot of output with no context:
"https://jsonplaceholder.typicode.com/posts/1"
%HTTPoison.Response{body: "{\n \"userId\": 1,\n \"id\": 1,\n \"title\": \"sunt aut facere
repellat provident occaecati excepturi optio reprehenderit\",\n \"body\": \"quia et
suscipit\\nsuscipit recusandae consequuntur expedita et cum\\nreprehenderit molestiae ut ut
quas totam\\nnostrum rerum est autem sunt rem eveniet architecto\"\n}",
headers: [{"Date", "Thu, 05 Jan 2017 14:29:59 GMT"},
{"Content-Type", "application/json; charset=utf-8"},
{"Content-Length", "292"}, {"Connection", "keep-alive"},
{"Set-Cookie",
"__cfduid=d56d1be0a544fcbdbb262fee9477600c51483626599; expires=Fri, 05-Jan-18 14:29:59 GMT;
path=/; domain=.typicode.com; HttpOnly"},
{"X-Powered-By", "Express"}, {"Vary", "Origin, Accept-Encoding"},
{"Access-Control-Allow-Credentials", "true"},
{"Cache-Control", "public, max-age=14400"}, {"Pragma", "no-cache"},
{"Expires", "Thu, 05 Jan 2017 18:29:59 GMT"},
{"X-Content-Type-Options", "nosniff"},
{"Etag", "W/\"124-yv65LoT2uMHrpn06wNpAcQ\""}, {"Via", "1.1 vegur"},
{"CF-Cache-Status", "HIT"}, {"Server", "cloudflare-nginx"},
{"CF-RAY", "31c7a025e94e2d41-TXL"}], status_code: 200}
"{\n \"userId\": 1,\n \"id\": 1,\n \"title\": \"sunt aut facere repellat provident
https://riptutorial.com/
12
occaecati excepturi optio reprehenderit\",\n \"body\": \"quia et suscipit\\nsuscipit
recusandae consequuntur expedita et cum\\nreprehenderit molestiae ut ut quas totam\\nnostrum
rerum est autem sunt rem eveniet architecto\"\n}"
%{"body" => "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit
molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto",
"id" => 1,
"title" => "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
"userId" => 1}
With labels
using the label option to add context can help a lot:
url
|> IO.inspect(label: "url")
|> HTTPoison.get!
|> IO.inspect(label: "raw http resonse")
|> Map.get(:body)
|> IO.inspect(label: "raw body")
|> Poison.decode!
|> IO.inspect(label: "parsed body")
url: "https://jsonplaceholder.typicode.com/posts/1"
raw http resonse: %HTTPoison.Response{body: "{\n \"userId\": 1,\n \"id\": 1,\n \"title\":
\"sunt aut facere repellat provident occaecati excepturi optio reprehenderit\",\n \"body\":
\"quia et suscipit\\nsuscipit recusandae consequuntur expedita et cum\\nreprehenderit
molestiae ut ut quas totam\\nnostrum rerum est autem sunt rem eveniet architecto\"\n}",
headers: [{"Date", "Thu, 05 Jan 2017 14:33:06 GMT"},
{"Content-Type", "application/json; charset=utf-8"},
{"Content-Length", "292"}, {"Connection", "keep-alive"},
{"Set-Cookie",
"__cfduid=d22d817e48828169296605d27270af7e81483626786; expires=Fri, 05-Jan-18 14:33:06 GMT;
path=/; domain=.typicode.com; HttpOnly"},
{"X-Powered-By", "Express"}, {"Vary", "Origin, Accept-Encoding"},
{"Access-Control-Allow-Credentials", "true"},
{"Cache-Control", "public, max-age=14400"}, {"Pragma", "no-cache"},
{"Expires", "Thu, 05 Jan 2017 18:33:06 GMT"},
{"X-Content-Type-Options", "nosniff"},
{"Etag", "W/\"124-yv65LoT2uMHrpn06wNpAcQ\""}, {"Via", "1.1 vegur"},
{"CF-Cache-Status", "HIT"}, {"Server", "cloudflare-nginx"},
{"CF-RAY", "31c7a4b8ae042d77-TXL"}], status_code: 200}
raw body: "{\n \"userId\": 1,\n \"id\": 1,\n \"title\": \"sunt aut facere repellat
provident occaecati excepturi optio reprehenderit\",\n \"body\": \"quia et
suscipit\\nsuscipit recusandae consequuntur expedita et cum\\nreprehenderit molestiae ut ut
quas totam\\nnostrum rerum est autem sunt rem eveniet architecto\"\n}"
parsed body: %{"body" => "quia et suscipit\nsuscipit recusandae consequuntur expedita et
cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet
architecto",
"id" => 1,
"title" => "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
"userId" => 1}
Read Better debugging with IO.inspect and labels online:
https://riptutorial.com/elixir/topic/8725/better-debugging-with-io-inspect-and-labels
https://riptutorial.com/
13
Chapter 8: Built-in types
Examples
Numbers
Elixir comes with integers and floating point numbers. An integer literal can be written in
decimal, binary, octal and hexadecimal formats.
iex> x = 291
291
iex> x = 0b100100011
291
iex> x = 0o443
291
iex> x = 0x123
291
As Elixir uses bignum arithmetic, the range of integer is only limited by the available memory
on the system.
Floating point numbers are double precision and follows IEEE-754 specification.
iex> x = 6.8
6.8
iex> x = 1.23e-11
1.23e-11
Note that Elixir also supports exponent form for floats.
iex> 1 + 1
2
iex> 1.0 + 1.0
2.0
First we added two integers numbers, and the result is an integer. Later we added two floating
point numbers, and the result is a floating point number.
Dividing in Elixir always returns a floating point number:
iex> 10 / 2
5.0
In the same way, if you add, subtract or multiply an integer by a floating point number the result
will be floating point:
https://riptutorial.com/
14
iex> 40.0 + 2
42.0
iex> 10 - 5.0
5.0
iex> 3 * 3.0
9.0
For integer division, one can use the div/2 function:
iex> div(10, 2)
5
Atoms
Atoms are constants that represent a name of some thing. The value of an atom is it's name. An
atom name starts with a colon.
:atom # that's how we define an atom
An atom's name is unique. Two atoms with the same names always are equal.
iex(1)> a = :atom
:atom
iex(2)> b = :atom
:atom
iex(3)> a == b
true
iex(4)> a === b
true
Booleans true and false, actually are atoms.
iex(1)> true == :true
true
iex(2)> true === :true
true
Atoms are stored in special atoms table. It's very important to know that this table is not garbage-
collected. So, if you want (or accidentally it is a fact) constantly create atoms - it is a bad idea.
Binaries and Bitstrings
Binaries in elixir are created using the Kernel.SpecialForms construct <<>>.
They are a powerful tool which makes Elixir very useful for working with binary protocols and
encodings.
https://riptutorial.com/
15
Binaries and bitstrings are specified using a comma delimited list of integers or variable values,
bookended by "<<" and ">>". They are composed of 'units', either a grouping of bits or a grouping
of bytes. The default grouping is a single byte (8 bits), specified using an integer:
<<222,173,190, 239>> # 0xDEADBEEF
Elixir strings also convert directly to binaries:
iex> <<0, "foo">>
<<0, 102, 111, 111>>
You can add "specifiers" to each "segment" of a binary, allowing you to encode:
•
•
•
Data Type
Size
Endianness
These specifiers are encoded by following each value or variable with the "::" operator:
<<102::integer-native>>
<<102::native-integer>> # Same as above
<<102::unsigned-big-integer>>
<<102::unsigned-big-integer-size(8)>>
<<102::unsigned-big-integer-8>> # Same as above
<<102::8-integer-big-unsigned>>
<<-102::signed-little-float-64>> # -102 as a little-endian Float64
<<-102::native-little-float-64>> # -102 as a Float64 for the current machine
The available data types you can use are:
•
•
•
•
•
•
•
•
•
integer
float
bits (alias for bitstring)
bitstring
binary
bytes (alias for binary)
utf8
utf16
utf32
Be aware that when specifying the 'size' of the binary segment, it varies according to the 'type'
chosen in the segment specifier:
•
•
•
integer (default) 1 bit
float 1 bit
binary 8 bits
Read Built-in types online: https://riptutorial.com/elixir/topic/1774/built-in-types
https://riptutorial.com/
16
Chapter 9: Conditionals
Remarks
Note that the do...end syntax is syntactic sugar for regular keyword lists, so you can actually do
this:
unless false, do: IO.puts("Condition is false")
# Outputs "Condition is false"
# With an `else`:
if false, do: IO.puts("Condition is true"), else: IO.puts("Condition is false")
# Outputs "Condition is false"
Examples
case
case {1, 2} do
{3, 4} ->
"This clause won't match."
{1, x} ->
"This clause will match and bind x to 2 in this clause."
_ ->
"This clause would match any value."
end
case is only used to match the given pattern of the particular data. Here , {1,2} is matching with
different case pattern that is given in the code example.
if and unless
if true do
"Will be seen since condition is true."
end
if false do
"Won't be seen since condition is false."
else
"Will be seen.
end
unless false do
"Will be seen."
end
unless true do
"Won't be seen."
else
"Will be seen."
end
https://riptutorial.com/
17
cond
cond do
0 == 1 -> IO.puts "0 = 1"
2 == 1 + 1 -> IO.puts "1 + 1 = 2"
3 == 1 + 2 -> IO.puts "1 + 2 = 3"
end
# Outputs "1 + 1 = 2" (first condition evaluating to true)
cond will raise a CondClauseError if no conditions are true.
cond do
1 == 2 -> "Hmmm"
"foo" == "bar" -> "What?"
end
# Error
This can be avoided by adding a condition that will always be true.
cond do
... other conditions
true -> "Default value"
end
Unless it is never expected to reach the default case, and the program should in fact crash at that
point.
with clause
with clause is used to combine matching clauses. It looks like we combine anonymous functions
or handle function with multiple bodies (matching clauses). Consider the case: we create a user,
insert it into DB, then create greet email and then send it to the user.
Without the with clause we might write something like this (I omitted functions implementations):
case create_user(user_params) do
{:ok, user} ->
case Mailer.compose_email(user) do
{:ok, email} ->
Mailer.send_email(email)
{:error, reason} ->
handle_error
end
{:error, changeset} ->
handle_error
end
Here we handle our business process's flow with case (it could be cond or if). That leads us to so-
called 'pyramid of doom', because we have to deal with possible conditions and decide: whether
move further or not. It would be much nicer to rewrite this code with with statement:
https://riptutorial.com/
18
with {:ok, user} <- create_user(user_params),
{:ok, email} <- Mailer.compose_email(user) do
{:ok, Mailer.send_email}
else
{:error, _reason} ->
handle_error
end
In the code snippet above we've rewrite nested case clauses with with. Within with we invoke some
functions (either anonymous or named) and pattern match on their outputs. If all matched, with
return do block result, or else block result otherwise.
We can omit else so with will return either do block result or the first fail result.
So, the value of with statement is its do block result.
Read Conditionals online: https://riptutorial.com/elixir/topic/2118/conditionals
https://riptutorial.com/
19
Chapter 10: Constants
Remarks
So this is a summary analysis I've done based on the methods listed at How do you define
constants in Elixir modules?. I'm posting it for a couple reasons:
•
•
•
Most Elixir documentation is quite thorough, but I found this key architectural decision
lacking guidance - so I would have requested it as a topic.
I wanted to get a little visibility and comments from others about the topic.
I also wanted to test out the new SO Documentation workflow. ;)
I've also uploaded the entire code to the GitHub repo elixir-constants-concept.
Examples
Module-scoped constants
defmodule MyModule do
@my_favorite_number 13
@use_snake_case "This is a string (use double-quotes)"
end
These are only accessible from within this module.
Constants as functions
Declare:
defmodule MyApp.ViaFunctions.Constants do
def app_version, do: "0.0.1"
def app_author, do: "Felix Orr"
def app_info, do: [app_version, app_author]
def bar, do: "barrific constant in function"
end
Consume with require:
defmodule MyApp.ViaFunctions.ConsumeWithRequire do
require MyApp.ViaFunctions.Constants
def foo() do
IO.puts MyApp.ViaFunctions.Constants.app_version
IO.puts MyApp.ViaFunctions.Constants.app_author
IO.puts inspect MyApp.ViaFunctions.Constants.app_info
end
# This generates a compiler error, cannot invoke `bar/0` inside a guard.
# def foo(_bar) when is_bitstring(bar) do
https://riptutorial.com/
20
# IO.puts "We just used bar in a guard: #{bar}"
# end
end
Consume with import:
defmodule MyApp.ViaFunctions.ConsumeWithImport do
import MyApp.ViaFunctions.Constants
def foo() do
IO.puts app_version
IO.puts app_author
IO.puts inspect app_info
end
end
This method allows for reuse of constants across projects, but they will not be usable within guard
functions that require compile-time constants.
Constants via macros
Declare:
defmodule MyApp.ViaMacros.Constants do
@moduledoc """
Apply with `use MyApp.ViaMacros.Constants, :app` or `import MyApp.ViaMacros.Constants,
:app`.
Each constant is private to avoid ambiguity when importing multiple modules
that each have their own copies of these constants.
"""
def app do
quote do
# This method allows sharing module constants which can be used in guards.
@bar "barrific module constant"
defp app_version, do: "0.0.1"
defp app_author, do: "Felix Orr"
defp app_info, do: [app_version, app_author]
end
end
defmacro __using__(which) when is_atom(which) do
apply(__MODULE__, which, [])
end
end
Consume with use:
defmodule MyApp.ViaMacros.ConsumeWithUse do
use MyApp.ViaMacros.Constants, :app
def foo() do
IO.puts app_version
IO.puts app_author
IO.puts inspect app_info
https://riptutorial.com/
21
end
def foo(_bar) when is_bitstring(@bar) do
IO.puts "We just used bar in a guard: #{@bar}"
end
end
This method allows you to use the @some_constant inside guards. I'm not even sure that the
functions would be strictly necessary.
Read Constants online: https://riptutorial.com/elixir/topic/6614/constants
https://riptutorial.com/
22
Chapter 11: Data Structures
Syntax
•
•
[head | tail] = [1, 2, 3, true] # one can use pattern matching to break up cons cells. This
assigns head to 1 and tail to [2, 3, true]
%{d: val} = %{d: 1, e: true} # this assigns val to 1; no variable d is created because the d on
the lhs is really just a symbol that is used to create the pattern %{:d => _} (note that hash
rocket notation allows one to have non-symbols as keys for maps just like in ruby)
Remarks
As for which data structure to us here are some brief remarks.
If you need an array data structure if you're going to be doing a lot of writing use lists. If instead
you are going to be doing a lot of read you should use tuples.
As for maps they are just simply how you do key value stores.
Examples
Lists
a = [1, 2, 3, true]
Note that these are stored in memory as linked lists. Id est this is a series of cons cells where the
head (List.hd/1) is the value of first item of the list and the tail (List.tail/1) is the value of the rest of
the list.
List.hd(a) = 1
List.tl(a) = [2, 3, true]
Tuples
b = {:ok, 1, 2}
Tuples are the equivalent of arrays in other languages. They are stored contiguously in memory.
Read Data Structures online: https://riptutorial.com/elixir/topic/1607/data-structures
https://riptutorial.com/
23
Chapter 12: Debugging Tips
Examples
Debugging with IEX.pry/0
Debugging with IEx.pry/0 is quite simple.
1.
2.
3.
require IEx in your module
Find the line of code you want to inspect
Add IEx.pry after the line
Now start your project (e.g. iex -S mix).
When the line with IEx.pry/0 is reached the program will stop and you have the chance to inspect.
It is like a breakpoint in a traditional debugger.
When you are finished just type respawn into the console.
require IEx;
defmodule Example do
def double_sum(x, y) do
IEx.pry
hard_work(x, y)
end
defp hard_work(x, y) do
2 * (x + y)
end
end
Debugging with IO.inspect/1
It is possible to use IO.inspect/1 as a tool to debug an elixir program.
defmodule MyModule do
def myfunction(argument_1, argument_2) do
IO.inspect(argument_1)
IO.inspect(argument_2)
end
end
It will print out argument_1 and argument_2 to the console. Since IO.inspect/1 returns its
argument it is very easy to include it in function calls or pipelines without breaking the flow:
do_something(a, b)
|> do_something_else(c)
# can be adorned with IO.inspect, with no change in functionality:
https://riptutorial.com/
24
do_something(IO.inspect(a), IO.inspect(b))
|> IO.inspect
do_something(IO.inspect(c))
Debug in pipe
defmodule Demo do
def foo do
1..10
|> Enum.map(&(&1 * &1)) |> p
|> Enum.filter(&rem(&1, 2) == 0) |> p
|> Enum.take(3) |> p
end
defp p(e) do
require Logger
Logger.debug inspect e, limit: :infinity
e
end
end
iex(1)> Demo.foo
23:23:55.171 [debug] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
23:23:55.171 [debug] [4, 16, 36, 64, 100]
23:23:55.171 [debug] [4, 16, 36]
[4, 16, 36]
Pry in pipe
defmodule Demo do
def foo do
1..10
|> Enum.map(&(&1 * &1))
|> Enum.filter(&rem(&1, 2) == 0) |> pry
|> Enum.take(3)
end
defp pry(e) do
require IEx
IEx.pry
e
end
end
iex(1)> Demo.foo
Request to pry #PID<0.117.0> at lib/demo.ex:11
def pry(e) do
require IEx
https://riptutorial.com/
25
IEx.pry
e
end
Allow? [Yn] Y
Interactive Elixir (1.3.2) - press Ctrl+C to exit (type h() ENTER for help)
pry(1)> e
[4, 16, 36, 64, 100]
pry(2)> respawn
Interactive Elixir (1.3.2) - press Ctrl+C to exit (type h() ENTER for help)
[4, 16, 36]
iex(1)>
Read Debugging Tips online: https://riptutorial.com/elixir/topic/2719/debugging-tips
https://riptutorial.com/
26
Chapter 13: Doctests
Examples
Introduction
When you document your code with @doc, you can supply code examples like so:
# myproject/lib/my_module.exs
defmodule MyModule do
@doc """
Given a number, returns `true` if the number is even, otherwise `false`.
## Example
iex> MyModule.even?(2)
true
iex> MyModule.even?(3)
false
"""
def even?(number) do
rem(number, 2) == 0
end
end
You can add the code examples as test cases into one of your test suites:
# myproject/test/doc_test.exs
defmodule DocTest do
use ExUnit.Case
doctest MyModule
end
Then, you can then run your tests with mix test.
Generating HTML documentation based on doctest
Because generating documentation is based on markdown, you have to do 2 things :
1/ Write your doctest and make your doctest examples clear to improve readability (It is better to
give a headline, like "examples" or "tests"). When you write your tests, do not forget to give 4
spaces to your tests code so that it will be formatting as code in the HTML documentation.
2/ Then, enter "mix docs" in console at the root of your elixir project to generate the HTML
documentation in the doc directory located in the root of your elixir project.
$> mix docs
Multiline doctests
https://riptutorial.com/
27
You can do a multiline doctest by using '...>' for the lines following the first
iex> Foo.Bar.somethingConditional("baz")
...> |> case do
...> {:ok, _} -> true
...> {:error, _} -> false
...> end
true
Read Doctests online: https://riptutorial.com/elixir/topic/2708/doctests
https://riptutorial.com/
28
Chapter 14: Ecto
Examples
Adding a Ecto.Repo in an elixir program
This can be done in 3 steps :
1.
You must define an elixir module which use Ecto.Repo and register your app as an otp_app.
defmodule Repo do
use Ecto.Repo, otp_app: :custom_app
end
2.
You must also define some config for the Repo which will allow you to connect to the
database. Here is an example with postgres.
config :custom_app, Repo,
adapter: Ecto.Adapters.Postgres,
database: "ecto_custom_dev",
username: "postgres_dev",
password: "postgres_dev",
hostname: "localhost",
# OR use a URL to connect instead
url: "postgres://postgres_dev:postgres_dev@localhost/ecto_custom_dev"
3.
Before using Ecto in your application, you need to ensure that Ecto is started before your
app is started. It can be done with registering Ecto in lib/custom_app.ex as a supervisor.
def start(_type, _args) do
import Supervisor.Spec
children = [
supervisor(Repo, [])
]
opts = [strategy: :one_for_one, name: MyApp.Supervisor]
Supervisor.start_link(children, opts)
end
"and" clause in a Repo.get_by/3
If you have an Ecto.Queryable, named Post, which has a title and an description.
You can fetch the Post with title: "hello" and description : "world" by performing :
MyRepo.get_by(Post, [title: "hello", description: "world"])
All of this is possible because Repo.get_by expects in second argument a Keyword List.
https://riptutorial.com/
29
Querying with dynamic fields
To query a field which name is contained in a variable, use the field function.
some_field = :id
some_value = 10
from p in Post, where: field(p, ^some_field) == ^some_value
Add custom data types to migration and to schema
(From this answer)
The example below adds an enumerated type to a postgres database.
First, edit the migration file (created with mix ecto.gen.migration):
def up do
# creating the enumerated type
execute("CREATE TYPE post_status AS ENUM ('published', 'editing')")
# creating a table with the column
create table(:posts) do
add :post_status, :post_status, null: false
end
end
def down do
drop table(:posts)
execute("DROP TYPE post_status")
end
Second, in the model file either add a field with an Elixir type :
schema "posts" do
field :post_status, :string
end
or implement the Ecto.Type behaviour.
A good example for the latter is the ecto_enum package and it can be used as a template. Its usage
is well documented on its github page.
This commit shows an example usage in a Phoenix project from adding enum_ecto to the project
and using the enumerated type in views and models.
Read Ecto online: https://riptutorial.com/elixir/topic/6524/ecto
https://riptutorial.com/
30
Chapter 15: Erlang
Examples
Using Erlang
Erlang modules are available as atoms. For example, the Erlang math module is available as
:math:
iex> :math.pi
3.141592653589793
Inspect an Erlang module
Use module_info on Erlang modules you wish to inspect:
iex> :math.module_info
[module: :math,
exports: [pi: 0, module_info: 0, module_info: 1, pow: 2, atan2: 2, sqrt: 1,
log10: 1, log2: 1, log: 1, exp: 1, erfc: 1, erf: 1, atanh: 1, atan: 1,
asinh: 1, asin: 1, acosh: 1, acos: 1, tanh: 1, tan: 1, sinh: 1, sin: 1,
cosh: 1, cos: 1],
attributes: [vsn: [113168357788724588783826225069997113388]],
compile: [options: [{:outdir,
'/private/tmp/erlang20160316-36404-xtp7cq/otp-OTP-18.3/lib/stdlib/src/../ebin'},
{:i,
'/private/tmp/erlang20160316-36404-xtp7cq/otp-OTP-18.3/lib/stdlib/src/../include'},
{:i,
'/private/tmp/erlang20160316-36404-xtp7cq/otp-OTP-
18.3/lib/stdlib/src/../../kernel/include'},
:warnings_as_errors, :debug_info], version: '6.0.2',
time: {2016, 3, 16, 16, 40, 35},
source: '/private/tmp/erlang20160316-36404-xtp7cq/otp-OTP-18.3/lib/stdlib/src/math.erl'],
native: false,
md5: <<85, 35, 110, 210, 174, 113, 103, 228, 63, 252, 81, 27, 224, 15, 64,
44>>]
Read Erlang online: https://riptutorial.com/elixir/topic/2716/erlang
https://riptutorial.com/
31
Chapter 16: ExDoc
Examples
Introduction
To generate documentation in HTML format from @doc and @moduledoc attributes in your source code,
add ex_doc and a markdown processor, right now ExDoc supports Earmark, Pandoc, Hoedown
and Cmark, as dependencies into your mix.exs file:
# config/mix.exs
def deps do
[{:ex_doc, "~> 0.11", only: :dev},
{:earmark, "~> 0.1", only: :dev}]
end
If you want to use another Markdown processor, you can find more information in the Changing
the Markdown tool section.
You can use Markdown within Elixir @doc and @moduledoc attributes.
Then, run mix docs.
One thing to keep in mind is that ExDoc allows configuration parameters, such as:
def project do
[app: :my_app,
version: "0.1.0-dev",
name: "My App",
source_url: "https://github.com/USER/APP",
homepage_url: "http://YOUR_PROJECT_HOMEPAGE",
deps: deps(),
docs: [logo: "path/to/logo.png",
output: "docs",
main: "README",
extra_section: "GUIDES",
extras: ["README.md", "CONTRIBUTING.md"]]]
end
You can see more information about this configuration options with mix help docs
Read ExDoc online: https://riptutorial.com/elixir/topic/3582/exdoc
https://riptutorial.com/
32
Chapter 17: ExUnit
Examples
Asserting Exceptions
Use assert_raise to test if an exception was raised. assert_raise takes in an Exception and a
function to be executed.
test "invalid block size" do
assert_raise(MerkleTree.ArgumentError, (fn() -> MerkleTree.new ["a", "b", "c"] end))
end
Wrap any code you want to test in an anonymous function and pass it to assert_raise.
Read ExUnit online: https://riptutorial.com/elixir/topic/3583/exunit
https://riptutorial.com/
33
Chapter 18: Functional programming in Elixir
Introduction
Let's try to implement the basic higher orders functions like map and reduce using Elixir
Examples
Map
Map is a function which will take an array and a function and return an array after applying that
function to each element in that list
defmodule MyList do
def map([], _func) do
[]
end
def map([head | tail], func) do
[func.(head) | map(tail, func)]
end
end
Copy paste in iex and execute:
MyList.map [1,2,3], fn a -> a * 5 end
Shorthand syntax is MyList.map [1,2,3], &(&1 * 5)
Reduce
Reduce is a function which will take an array, function and accumulator and use accumulator as
seed to start the iteration with the first element to give next accumulator and the iteration
continues for all the elements in the array (refer below example)
defmodule MyList do
def reduce([], _func, acc) do
acc
end
def reduce([head | tail], func, acc) do
reduce(tail, func, func.(acc, head))
end
end
Copy paste the above snippet in iex:
1.
To add all numbers in an array: MyList.reduce [1,2,3,4], fn acc, element -> acc + element
end, 0
https://riptutorial.com/
34
2.
To mutliply all numbers in an array: MyList.reduce [1,2,3,4], fn acc, element -> acc *
element end, 1
Explanation for example 1:
Iteration 1 => acc = 0, element = 1 ==> 0 + 1 ===> 1 = next accumulator
Iteration 2 => acc = 1, element = 2 ==> 1 + 2 ===> 3 = next accumulator
Iteration 3 => acc = 3, element = 3 ==> 3 + 3 ===> 6 = next accumulator
Iteration 4 => acc = 6, element = 4 ==> 6 + 4 ===> 10 = next accumulator = result(as all
elements are done)
Filter the list using reduce
MyList.reduce [1,2,3,4], fn acc, element -> if rem(element,2) == 0 do acc else acc ++
[element] end end, []
Read Functional programming in Elixir online: https://riptutorial.com/elixir/topic/10186/functional-
programming-in-elixir
https://riptutorial.com/
35
Chapter 19: Functions
Examples
Anonymous Functions
In Elixir, a common practice is to use anonymous functions. Creating an anonymous function is
simple:
iex(1)> my_func = fn x -> x * 2 end
#Function<6.52032458/1 in :erl_eval.expr/5>
The general syntax is:
fn args -> output end
For readability, you may put parenthesis around the arguments:
iex(2)> my_func = fn (x, y) -> x*y end
#Function<12.52032458/2 in :erl_eval.expr/5>
To invoke an anonymous function, call it by the assigned name and add . between the name and
arguments.
iex(3)>my_func.(7, 5)
35
It is possible to declare anonymous functions without arguments:
iex(4)> my_func2 = fn -> IO.puts "hello there" end
iex(5)> my_func2.()
hello there
:ok
Using the capture operator
To make anonymous functions more concise you can use the capture operator &. For example,
instead of:
iex(5)> my_func = fn (x) -> x*x*x end
You can write:
iex(6)> my_func = &(&1*&1*&1)
https://riptutorial.com/
36
With multiple parameters, use the number corresponding to each argument, counting from 1:
iex(7)> my_func = fn (x, y) -> x + y end
iex(8)> my_func = &(&1 + &2) # &1 stands for x and &2 stands for y
iex(9)> my_func.(4, 5)
9
Multiple bodies
An anonymous function can also have multiple bodies (as a result of pattern matching):
my_func = fn
param1 -> do_this
param2 -> do_that
end
When you call a function with multiple bodies Elixir attempts to match the parameters you have
provided with the proper function body.
Keyword lists as function parameters
Use keyword lists for 'options'-style parameters that contains multiple key-value pairs:
def myfunc(arg1, opts \\ []) do
# Function body
end
We can call the function above like so:
iex> myfunc "hello", pizza: true, soda: false
which is equivalent to:
iex> myfunc("hello", [pizza: true, soda: false])
The argument values are available as opts.pizza and opts.soda respectively.
Alternatively, you could use atoms: opts[:pizza] and opts[:soda].
Named Functions & Private Functions
Named Functions
defmodule Math do
# one way
def add(a, b) do
a + b
https://riptutorial.com/
37
end
# another way
def subtract(a, b), do: a - b
end
iex> Math.add(2, 3)
5
:ok
iex> Math.subtract(5, 2)
3
:ok
Private Functions
defmodule Math do
def sum(a, b) do
add(a, b)
end
# Private Function
defp add(a, b) do
a + b
end
end
iex> Math.add(2, 3)
** (UndefinedFunctionError) undefined function Math.add/2
Math.add(3, 4)
iex> Math.sum(2, 3)
5
Pattern Matching
Elixir matches a function call to its body based on the value of its arguments.
defmodule Math do
def factorial(0): do: 1
def factorial(n): do: n * factorial(n - 1)
end
Here, factorial of positive numbers matches the second clause, while factorial(0) matches the
first. (ignoring negative numbers for the sake of simplicity). Elixir tries to match the functions from
top to bottom. If the second function is written above the first, we will an unexpected result as it
goes to an endless recursion. Because factorial(0) matches to factorial(n)
Guard clauses
Guard clauses enables us to check the arguments before executing the function. Guard clauses
are usually preferred to if and cond due to their readability, and to make a certain optimization
technique easier for the compiler. The first function definition where all guards match is executed.
Here is an example implementation of the factorial function using guards and pattern matching.
https://riptutorial.com/
38
defmodule Math do
def factorial(0), do: 1
def factorial(n) when n > 0: do: n * factorial(n - 1)
end
The first pattern matches if (and only if) the argument is 0. If the argument is not 0, the pattern
match fails and the next function below is checked.
That second function definition has a guard clause: when n > 0. This means that this function only
matches if the argument n is greater than 0. After all, the mathematical factorial function is not
defined for negative integers.
If neither function definition (including their pattern matching and guard clauses) match, a
FunctionClauseError will be raised. This happens for this function when we pass a negative number
as the argument, since it is not defined for negative numbers.
Note that this FunctionClauseError itself, is not a mistake. Returning -1 or 0 or some other "error
value" as is common in some other languages would hide the fact that you called an undefined
function, hiding the source of the error, possibly creating a huge painful bug for a future developer.
Default Parameters
You can pass default parameters to any named function using the syntax: param \\ value:
defmodule Example do
def func(p1, p2 \\ 2) do
IO.inspect [p1, p2]
end
end
Example.func("a") # => ["a", 2]
Example.func("b", 4) # => ["b", 4]
Capture functions
Use & to capture functions from other modules. You can use the captured functions directly as
function parameters or within anonymous functions.
Enum.map(list, fn(x) -> String.capitalize(x) end)
Can be made more concise using &:
Enum.map(list, &String.capitalize(&1))
Capturing functions without passing any arguments require you to explicitly specify its arity, e.g.
&String.capitalize/1:
defmodule Bob do
def say(message, f \\ &String.capitalize/1) do
f.(message)
https://riptutorial.com/
39
end
end
Read Functions online: https://riptutorial.com/elixir/topic/2442/functions
https://riptutorial.com/
40
Chapter 20: Getting help in IEx console
Introduction
IEx provides access to Elixir documentation. When Elixir is installed on your system you can start
IEx e.g. with iex command in a terminal. Then type h command on IEx command line followed by
the function name prepended by its module name e.g. h List.foldr
Examples
Listing Elixir modules and functions
To get the list of Elixir modules just type
h Elixir.[TAB]
Pressing [TAB] autocompletes modules and functions names. In this case it lists all modules. To
find all functions in a module e.g. List use
h List.[TAB]
Read Getting help in IEx console online: https://riptutorial.com/elixir/topic/10780/getting-help-in-
iex-console
https://riptutorial.com/
41
Chapter 21: IEx Console Tips & Tricks
Examples
Recompile project with `recompile`
iex(1)> recompile
Compiling 1 file (.ex)
:ok
See documentation with `h`
iex(1)> h List.last
def last(list)
Returns the last element in list or nil if list is empty.
Examples
┃ iex> List.last([])
┃ nil
┃
┃ iex> List.last([1])
┃ 1
┃
┃ iex> List.last([1, 2, 3])
┃ 3
Get value from last command with `v`
iex(1)> 1 + 1
2
iex(2)> v
2
iex(3)> 1 + v
3
See also: Get the value of a row with `v`
Get the value of a previous command with `v`
iex(1)> a = 10
10
iex(2)> b = 20
20
iex(3)> a + b
30
You can get a specific row passing the index of the row:
https://riptutorial.com/
42
iex(4)> v(3)
30
You can also specify an index relative to the current row:
iex(5)> v(-1) # Retrieves value of row (5-1) -> 4
30
iex(6)> v(-5) # Retrieves value of row (5-4) -> 1
10
The value can be reused in other calculations:
iex(7)> v(2) * 4
80
If you specify a non-existing row, IEx will raise an error:
iex(7)> v(100)
** (RuntimeError) v(100) is out of bounds
(iex) lib/iex/history.ex:121: IEx.History.nth/2
(iex) lib/iex/helpers.ex:357: IEx.Helpers.v/1
Exit IEx console
1.
Use Ctrl + C, Ctrl + C to exit
iex(1)>
BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
(v)ersion (k)ill (D)b-tables (d)istribution
2.
Use Ctrl+ \ to immediately exit
See information with `i`
iex(1)> i :ok
Term
:ok
Data type
Atom
Reference modules
Atom
iex(2)> x = "mystring"
"mystring"
iex(3)> i x
Term
"mystring"
Data type
BitString
Byte size
8
Description
This is a string: a UTF-8 encoded binary. It's printed surrounded by
"double quotes" because all UTF-8 encoded codepoints in it are printable.
https://riptutorial.com/
43
Raw representation
<<109, 121, 115, 116, 114, 105, 110, 103>>
Reference modules
String, :binary
Creating PID
This is useful when you didn't store the PID from a previous command
iex(1)> self()
#PID<0.138.0>
iex(2)> pid("0.138.0")
#PID<0.138.0>
iex(3)> pid(0, 138, 0)
#PID<0.138.0>
Have your aliases ready when you start IEx
If you put your commonly used aliases into an .iex.exs file at the root of your app, IEx will load
them for you on startup.
alias App.{User, Repo}
Persistent history
By default, user input history in IEx do not persist across different sessions.
erlang-history adds history support to both the Erlang shell and IEx:
git clone git@github.com:ferd/erlang-history.git
cd erlang-history
sudo make install
You can now access your previous inputs using the up and down arrow keys, even across
different IEx sessions.
When Elixir console is stuck...
Sometimes you might accidentally run something in the shell that ends up waiting forever, and
thus blocking the shell:
iex(2)> receive do _ -> :stuck end
In that case, press Ctrl-g. You'll see:
User switch command
Enter these commands in order:
•
k (to kill the shell process)
https://riptutorial.com/
44
•
•
s (to start a new shell process)
c (to connect to the new shell process)
You'll end up in a new Erlang shell:
Eshell V8.0.2 (abort with ^G)
1>
To start an Elixir shell, type:
'Elixir.IEx.CLI':local_start().
(don't forget the final dot!)
Then you'll see a new Elixir shell process coming up:
Interactive Elixir (1.3.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> "I'm back"
"I'm back"
iex(2)>
To escape from “awaiting-for-more-input” mode (due to unclosed quotation mark, bracket etc,)
type #iex:break, followed by carriage return ((cid:0)):
iex(1)> "Hello, "world"
...(1)>
...(1)> #iex:break
** (TokenMissingError) iex:1: incomplete expression
iex(1)>
the above is specifically useful when copy-pasting a relatively huge snippet turns the console to
“awaiting-for-more-input” mode.
break out of incomplete expression
When you have entered something into IEx which expects a completion, such as a multiline string,
IEx will change the prompt to indicate that it is waiting for you finish by changing the prompt to
have an ellipsis (...) rather than iex.
If you find that IEx is waiting for you to finish an expression but you aren't sure what it needs to
terminate the expression, or you simply want to abort this line of input, enter #iex:break as the
console input. This will cause IEx to throw a TokenMissingError and cancel waiting for any more
input, returning you to a standard "top-level" console input.
iex:1> "foo"
"foo"
iex:2> "bar
...:2> #iex:break
** (TokenMissingError) iex:2: incomplete expression
https://riptutorial.com/
45
More info is available at the IEx documentation.
Load a module or script into the IEx session
If you have an elixir file; a script or a module and want to load it into the current IEx session, you
can use the c/1 method:
iex(1)> c "lib/utils.ex"
iex(2)> Utils.some_method
This will compile and load the module in IEx, and you'll be able to call all of it's public methods.
For scripts, it will immediately execute the contents of the script:
iex(3)> c "/path/to/my/script.exs"
Called from within the script!
Read IEx Console Tips & Tricks online: https://riptutorial.com/elixir/topic/1283/iex-console-tips---
tricks
https://riptutorial.com/
46
Chapter 22: Installation
Examples
Fedora Installation
dnf install erlang elixir
OSX Installation
On OS X and MacOS, Elixir can be installed via the common package managers:
Homebrew
$ brew update
$ brew install elixir
Macports
$ sudo port install elixir
Debian/Ubuntu Installation
# Fetch and install package to setup access to the official APT repository
wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
sudo dpkg -i erlang-solutions_1.0_all.deb
# Update package index
sudo apt-get update
# Install Erlang and Elixir
sudo apt-get install esl-erlang
sudo apt-get install elixir
Gentoo/Funtoo Installation
Elixir is available in main packages repository.
Update the packages list before installing any package:
emerge --sync
This is one step installation:
https://riptutorial.com/
47
emerge --ask dev-lang/elixir
Read Installation online: https://riptutorial.com/elixir/topic/4208/installation
https://riptutorial.com/
48
Chapter 23: Join Strings
Examples
Using String Interpolation
iex(1)> [x, y] = ["String1", "String2"]
iex(2)> "#{x} #{y}"
# "String1 String2"
Using IO List
["String1", " ", "String2"] |> IO.iodata_to_binary
# "String1 String2"
This will gives some performances boosts as strings not duplicated in memory.
Alternative method:
iex(1)> IO.puts(["String1", " ", "String2"])
# String1 String2
Using Enum.join
Enum.join(["String1", "String2"], " ")
# "String1 String2"
Read Join Strings online: https://riptutorial.com/elixir/topic/9202/join-strings
https://riptutorial.com/
49
Chapter 24: Lists
Syntax
•
•
•
•
•
•
•
•
•
•
•
[]
[1, 2, 3, 4]
[1, 2] ++ [3, 4] # -> [1,2,3,4]
hd([1, 2, 3, 4]) # -> 1
tl([1, 2, 3, 4]) # -> [2,3,4]
[head | tail]
[1 | [2, 3, 4]] # -> [1,2,3,4]
[1 | [2 | [3 | [4 | []]]]] -> [1,2,3,4]
'hello' = [?h, ?e, ?l, ?l, ?o]
keyword_list = [a: 123, b: 456, c: 789]
keyword_list[:a] # -> 123
Examples
Keyword Lists
Keyword lists are lists where each item in the list is a tuple of an atom followed by a value.
keyword_list = [{:a, 123}, {:b, 456}, {:c, 789}]
A shorthand notation for writing keyword lists is as follows:
keyword_list = [a: 123, b: 456, c: 789]
Keyword lists are useful for creating ordered key-value pair data structures, where multiple items
can exist for a given key.
The first item in a keyword list for a given key can be obtained like so:
iex> keyword_list[:b]
456
A use case for keyword lists could be a sequence of named tasks to run:
defmodule TaskRunner do
def run_tasks(tasks) do
# Call a function for each item in the keyword list.
# Use pattern matching on each {:key, value} tuple in the keyword list
Enum.each(tasks, fn
{:delete, x} ->
IO.puts("Deleting record " <> to_string(x) <> "...")
{:add, value} ->
https://riptutorial.com/
50
IO.puts("Adding record \"" <> value <> "\"...")
{:update, {x, value}} ->
IO.puts("Setting record " <> to_string(x) <> " to \"" <> value <> "\"...")
end)
end
end
This code can be called with a keyword list like so:
iex> tasks = [
...> add: "foo",
...> add: "bar",
...> add: "test",
...> delete: 2,
...> update: {1, "asdf"}
...> ]
iex> TaskRunner.run_tasks(tasks)
Adding record "foo"...
Adding record "bar"...
Adding record "test"...
Deleting record 2...
Setting record 1 to "asdf"...
Char Lists
Strings in Elixir are "binaries". However, in Erlang code, strings are traditionally "char lists", so
when calling Erlang functions, you may have to use char lists instead of regular Elixir strings.
While regular strings are written using double quotes ", char lists are written using single quotes ':
string = "Hello!"
char_list = 'Hello!'
Char lists are simply lists of integers representing the code points of each character.
'hello' = [104, 101, 108, 108, 111]
A string can be converted to a char list with to_charlist/1:
iex> to_charlist("hello")
'hello'
And the reverse can be done with to_string/1:
iex> to_string('hello')
"hello"
Calling an Erlang function and converting the output to a regular Elixir string:
iex> :os.getenv |> hd |> to_string
"PATH=/usr/local/bin:/usr/bin:/bin"
https://riptutorial.com/
51
Cons Cells
Lists in Elixir are linked lists. This means that each item in a list consists of a value, followed by a
pointer to the next item in the list. This is implemented in Elixir using cons cells.
Cons cells are simple data structures with a "left" and a "right" value, or a "head" and a "tail".
A | symbol can be added before the last item in a list to notate an (improper) list with a given head
and tail. The following is a single cons cell with 1 as the head and 2 as the tail:
[1 | 2]
The standard Elixir syntax for a list is actually equivalent to writing a chain of nested cons cells:
[1, 2, 3, 4] = [1 | [2 | [3 | [4 | []]]]]
The empty list [] is used as the tail of a cons cell to represent the end of a list.
All lists in Elixir are equivalent to the form [head | tail], where head is the first item of the list and
tail is the rest of the list, minus the head.
iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]
iex> head
1
iex> tail
[2, 3, 4]
Using the [head | tail] notation is useful for pattern matching in recursive functions:
def sum([]), do: 0
def sum([head | tail]) do
head + sum(tail)
end
Mapping Lists
map is a function in functional programming which given a list and a function, returns a new list with
the function applied to each item in that list. In Elixir, the map/2 function is in the Enum module.
iex> Enum.map([1, 2, 3, 4], fn(x) -> x + 1 end)
[2, 3, 4, 5]
Using the alternative capture syntax for anonymous functions:
iex> Enum.map([1, 2, 3, 4], &(&1 + 1))
[2, 3, 4, 5]
https://riptutorial.com/
52
Referring to a function with capture syntax:
iex> Enum.map([1, 2, 3, 4], &to_string/1)
["1", "2", "3", "4"]
Chaining list operations using the pipe operator:
iex> [1, 2, 3, 4]
...> |> Enum.map(&to_string/1)
...> |> Enum.map(&("Chapter " <> &1))
["Chapter 1", "Chapter 2", "Chapter 3", "Chapter 4"]
List Comprehensions
Elixir doesn't have loops. Instead of them for lists there are great Enum and List modules, but there
are also List Comprehensions.
List Comprehensions can be useful to:
•
create new lists
iex(1)> for value <- [1, 2, 3], do: value + 1
[2, 3, 4]
•
filtering lists, using guard expressions but you use them without when keyword.
iex(2)> odd? = fn x -> rem(x, 2) == 1 end
iex(3)> for value <- [1, 2, 3], odd?.(value), do: value
[1, 3]
•
create custom map, using into keyword:
iex(4)> for value <- [1, 2, 3], into: %{}, do: {value, value + 1}
%{1 => 2, 2=>3, 3 => 4}
Combined example
iex(5)> for value <- [1, 2, 3], odd?.(value), into: %{}, do: {value, value * value}
%{1 => 1, 3 => 9}
Summary
List Comprehensions:
•
uses for..do syntax with additional guards after commas and into keyword when returning
other structure than lists ie. map.
https://riptutorial.com/
53
•
•
•
•
in other cases return new lists
doesn't support accumulators
can't stop processing when certain condition is met
guard statements have to be first in order after for and before do or into symbols. Order of
symbols doesn't matter
According to these constraints List Comprehensions are limited only for simple usage. In more
advanced cases using functions from Enum and List modules would be the best idea.
List difference
iex> [1, 2, 3] -- [1, 3]
[2]
-- removes the first occurrence of an item on the left list for each item on the right.
List Membership
Use in operator to check if an element is a member of a list.
iex> 2 in [1, 2, 3]
true
iex> "bob" in [1, 2, 3]
false
Converting Lists to a Map
Use Enum.chunk/2 to group elements into sub-lists, and Map.new/2 to convert it into a Map:
[1, 2, 3, 4, 5, 6]
|> Enum.chunk(2)
|> Map.new(fn [k, v] -> {k, v} end)
Would give:
%{1 => 2, 3 => 4, 5 => 6}
Read Lists online: https://riptutorial.com/elixir/topic/1279/lists
https://riptutorial.com/
54
Chapter 25: Maps and Keyword Lists
Syntax
•
•
•
•
map = %{} // creates an empty map
map = %{:a => 1, :b => 2} // creates a non-empty map
list = [] // creates an empty list
list = [{:a, 1}, {:b, 2}] // creates a non-empty keyword list
Remarks
Elixir provides two associative data structures: maps and keyword lists.
Maps are the Elixir key-value (also called dictionary or hash in other languages) type.
Keyword lists are tuples of key/value that associate a value to a certain key. They are generally
used as options for a function call.
Examples
Creating a Map
Maps are the Elixir key-value (also called dictionary or hash in other languages) type. You create a
map using the %w{} syntax:
%{} // creates an empty map
%{:a => 1, :b => 2} // creates a non-empty map
Keys and values can use be any type:
%{"a" => 1, "b" => 2}
%{1 => "a", 2 => "b"}
Moreover, you can have maps with mixed types for both keys and values":
// keys are integer or strings
%{1 => "a", "b" => :foo}
// values are string or nil
%{1 => "a", 2 => nil}
When all the keys in a map are atoms, you can use the keyword syntax for convenience:
%{a: 1, b: 2}
Creating a Keyword List
https://riptutorial.com/
55
Keyword lists are tuples of key/value, generally used as options for a function call.
[{:a, 1}, {:b, 2}] // creates a non-empty keyword list
Keyword lists can have the same key repeated more than once.
[{:a, 1}, {:a, 2}, {:b, 2}]
[{:a, 1}, {:b, 2}, {:a, 2}]
Keys and values can be any type:
[{"a", 1}, {:a, 2}, {2, "b"}]
Difference between Maps and Keyword Lists
Maps and keyword lists have different application. For instance, a map cannot have two keys with
the same value and it's not ordered. Conversely, a Keyword list can be a little bit hard to use in
pattern matching in some cases.
Here's a few use cases for maps vs keyword lists.
Use keyword lists when:
•
•
you need the elements to be ordered
you need more than one element with the same key
Use maps when:
•
•
•
you want to pattern-match against some keys/values
you don't need more than one element with the same key
whenever you don't explicitly need a keyword list
Read Maps and Keyword Lists online: https://riptutorial.com/elixir/topic/2706/maps-and-keyword-
lists
https://riptutorial.com/
56
Chapter 26: Metaprogramming
Examples
Generate tests at compile time
defmodule ATest do
use ExUnit.Case
[{1, 2, 3}, {10, 20, 40}, {100, 200, 300}]
|> Enum.each(fn {a, b, c} ->
test "#{a} + #{b} = #{c}" do
assert unquote(a) + unquote(b) = unquote(c)
end
end)
end
Output:
.
1) test 10 + 20 = 40 (Test.Test)
test.exs:6
match (=) failed
code: 10 + 20 = 40
rhs: 40
stacktrace:
test.exs:7
.
Finished in 0.1 seconds (0.1s on load, 0.00s on tests)
3 tests, 1 failure
Read Metaprogramming online: https://riptutorial.com/elixir/topic/4069/metaprogramming
https://riptutorial.com/
57
Chapter 27: Mix
Examples
Create a Custom Mix Task
# lib/mix/tasks/mytask.ex
defmodule Mix.Tasks.MyTask do
use Mix.Task
@shortdoc "A simple mix task"
def run(_) do
IO.puts "YO!"
end
end
Compile and run:
$ mix compile
$ mix my_task
"YO!"
Custom mix task with command line arguments
In a basic implementation the task module must define a run/1 function that takes a list of
arguments. E.g. def run(args) do ... end
defmodule Mix.Tasks.Example_Task do
use Mix.Task
@shortdoc "Example_Task prints hello + its arguments"
def run(args) do
IO.puts "Hello #{args}"
end
end
Compile and run:
$ mix example_task world
"hello world"
Aliases
Elixir allows you to add aliases for your mix commands. Cool thing if you want to save yourself
some typing.
Open mix.exs in your Elixir project.
First, add aliases/0 function to the keyword list that the project function returns. Adding () at the
https://riptutorial.com/
58
end of the aliases function will prevent compiler from throwing a warning.
def project do
[app: :my_app,
...
aliases: aliases()]
end
Then, define your aliases/0 function (e.g. at the bottom of your mix.exs file).
...
defp aliases do
[go: "phoenix.server",
trident: "do deps.get, compile, go"]
end
You can now use $ mix go to run your Phoenix server (if you're running a Phoenix application).
And use $ mix trident to tell mix to fetch all dependencies, compile, and run the server.
Get help on available mix tasks
To list available mix tasks use:
mix help
To get help on a specific task use mix help task e.g.:
mix help cmd
Read Mix online: https://riptutorial.com/elixir/topic/3585/mix
https://riptutorial.com/
59
Chapter 28: Modules
Remarks
Module Names
In Elixir, module names such as IO or String are just atoms under the hood and are converted to
the form :"Elixir.ModuleName" at compile time.
iex(1)> is_atom(IO)
true
iex(2)> IO == :"Elixir.IO"
true
Examples
List a module's functions or macros
The __info__/1 function takes one of the following atoms:
•
•
:functions - Returns a keyword list of public functions along with their arities
:macros - Returns a keyword list of public macros along with their arities
To list the Kernel module’s functions:
iex> Kernel.__info__ :functions
[!=: 2, !==: 2, *: 2, +: 1, +: 2, ++: 2, -: 1, -: 2, --: 2, /: 2, <: 2, <=: 2,
==: 2, ===: 2, =~: 2, >: 2, >=: 2, abs: 1, apply: 2, apply: 3, binary_part: 3,
bit_size: 1, byte_size: 1, div: 2, elem: 2, exit: 1, function_exported?: 3,
get_and_update_in: 3, get_in: 2, hd: 1, inspect: 1, inspect: 2, is_atom: 1,
is_binary: 1, is_bitstring: 1, is_boolean: 1, is_float: 1, is_function: 1,
is_function: 2, is_integer: 1, is_list: 1, is_map: 1, is_number: 1, is_pid: 1,
is_port: 1, is_reference: 1, is_tuple: 1, length: 1, macro_exported?: 3,
make_ref: 0, ...]
Replace Kernel with any module of your choosing.
Using modules
Modules have four associated keywords to make using them in other modules: alias, import, use,
and require.
alias will register a module under a different (usually shorter) name:
defmodule MyModule do
# Will make this module available as `CoolFunctions`
alias MyOtherModule.CoolFunctions
# Or you can specify the name to use
https://riptutorial.com/
60
alias MyOtherModule.CoolFunctions, as: CoolFuncs
end
import will make all the functions in the module available with no name in front of them:
defmodule MyModule do
import Enum
def do_things(some_list) do
# No need for the `Enum.` prefix
join(some_list, " ")
end
end
use allows a module to inject code into the current module - this is typically done as part of a
framework that creates its own functions to make your module confirm to some behaviour.
require loads macros from the module so that they can be used.
Delegating functions to another module
Use defdelegate to define functions that delegate to functions of the same name defined in another
module:
defmodule Math do
defdelegate pi, to: :math
end
iex> Math.pi
3.141592653589793
Read Modules online: https://riptutorial.com/elixir/topic/2721/modules
https://riptutorial.com/
61
Chapter 29: Nodes
Examples
List all visible nodes in the system
iex(bob@127.0.0.1)> Node.list
[:"frank@127.0.0.1"]
Connecting nodes on the same machine
Start two named nodes in two terminal windows:
>iex --name bob@127.0.0.1
iex(bob@127.0.0.1)>
>iex --name frank@127.0.0.1
iex(frank@127.0.0.1)>
Connect two nodes by instructing one node to connect:
iex(bob@127.0.0.1)> Node.connect :"frank@127.0.0.1"
true
The two nodes are now connected and aware of each other:
iex(bob@127.0.0.1)> Node.list
[:"frank@127.0.0.1"]
iex(frank@127.0.0.1)> Node.list
[:"bob@127.0.0.1"]
You can execute code on other nodes:
iex(bob@127.0.0.1)> greet = fn() -> IO.puts("Hello from #{inspect(Node.self)}") end
iex(bob@127.0.0.1)> Node.spawn(:"frank@127.0.0.1", greet)
#PID<9007.74.0>
Hello from :"frank@127.0.0.1"
:ok
Connecting nodes on different machines
Start a named process on one IP address:
$ iex --name foo@10.238.82.82 --cookie chocolate
iex(foo@10.238.82.82)> Node.ping :"bar@10.238.82.85"
:pong
iex(foo@10.238.82.82)> Node.list
[:"bar@10.238.82.85"]
https://riptutorial.com/
62
Start another named process on a different IP address:
$ iex --name bar@10.238.82.85 --cookie chocolate
iex(bar@10.238.82.85)> Node.list
[:"foo@10.238.82.82"]
Read Nodes online: https://riptutorial.com/elixir/topic/2065/nodes
https://riptutorial.com/
63
Chapter 30: Operators
Examples
The Pipe Operator
The Pipe Operator |> takes the result of an expression on the left and feeds it as the first
parameter to a function on the right.
expression |> function
Use the Pipe Operator to chain expressions together and to visually document the flow of a series
of functions.
Consider the following:
Oven.bake(Ingredients.Mix([:flour, :cocoa, :sugar, :milk, :eggs, :butter]), :temperature)
In the example, Oven.bake comes before Ingredients.mix, but it is executed last. Also, it may not be
obvious that :temperature is a parameter of Oven.bake
Rewriting this example using the Pipe Operator:
[:flour, :cocoa, :sugar, :milk, :eggs, :butter]
|> Ingredients.mix
|> Oven.bake(:temperature)
gives the same result, but the order of execution is clearer. Furthermore, it is clear that
:temperature is a parameter to the Oven.bake call.
Note that when using the Pipe Operator, the first parameter for each function is relocated to before
the Pipe Operator, and so the function being called appears to have one fewer parameter. For
instance:
Enum.each([1, 2, 3], &(&1+1)) # produces [2, 3, 4]
is the same as:
[1, 2, 3]
|> Enum.each(&(&1+1))
Pipe operator and parentheses
Parentheses are needed to avoid ambiguity:
foo 1 |> bar 2 |> baz 3
https://riptutorial.com/
64
Should be written as:
foo(1) |> bar(2) |> baz(3)
Boolean operators
There are two kinds of boolean operators in Elixir:
•
boolean operators (they expect either true or false as their first argument)
x or y # true if x is true, otherwise y
x and y # false if x is false, otherwise y
not x # false if x is true, otherwise true
All of booleans operators will raise ArgumentError if first argument won't be strictly boolean value,
which means only true or false (nil is not boolean).
iex(1)> false and 1 # return false
iex(2)> false or 1 # return 1
iex(3)> nil and 1 # raise (ArgumentError) argument error: nil
•
relaxed boolean operators (work with any type, everything that neither false nor nil is
considered as true)
x || y # x if x is true, otherwise y
x && y # y if x is true, otherwise false
!x # false if x is true, otherwise true
Operator || will always return first argument if it's truthy (Elixir treats everything except nil and
false to be true in comparisions), otherwise will return second one.
iex(1)> 1 || 3 # return 1, because 1 is truthy
iex(2)> false || 3 # return 3
iex(3)> 3 || false # return 3
iex(4)> false || nil # return nil
iex(5)> nil || false # return false
Operator && will always return second argument if it's truthy. Otherwise will return respectively to
the arguments, false or nil.
iex(1)> 1 && 3 # return 3, first argument is truthy
iex(2)> false && 3 # return false
iex(3)> 3 && false # return false
iex(4)> 3 && nil # return nil
iex(5)> false && nil # return false
iex(6)> nil && false # return nil
https://riptutorial.com/
65
Both && and || are short-circuit operators. They only execute the right side if the left side is not
enough to determine the result.
Operator ! will return boolean value of negation of current term:
iex(1)> !2 # return false
iex(2)> !false # return true
iex(3)> !"Test" # return false
iex(4)> !nil # return true
Simple way to get boolean value of selected term is to simply double this operator:
iex(1)> !!true # return true
iex(2)> !!"Test" # return true
iex(3)> !!nil # return false
iex(4)> !!false # return false
Comparison operators
Equality:
•
•
•
•
value equality x == y (1 == 1.0 # true)
value inequality x == y (1 != 1.0 # false)
strict equality x === y (1 === 1.0 # false)
strict inequality x === y (1 !== 1.0 # true)
Comparison:
•
•
•
•
x > y
x >= y
x < y
x <= y
If types are compatible, comparison uses natural ordering. Otherwise there is general types
comparison rule:
number < atom < reference < function < port < pid < tuple < map < list < binary
Join operators
You can join (concatenate) binaries (including strings) and lists:
iex(1)> [1, 2, 3] ++ [4, 5]
[1, 2, 3, 4, 5]
iex(2)> [1, 2, 3, 4, 5] -- [1, 3]
[2, 4, 5]
iex(3)> "qwe" <> "rty"
"qwerty"
https://riptutorial.com/
66
'In' operator
in operator allows you to check whether a list or a range includes an item:
iex(4)> 1 in [1, 2, 3, 4]
true
iex(5)> 0 in (1..5)
false
Read Operators online: https://riptutorial.com/elixir/topic/1161/operators
https://riptutorial.com/
67
Chapter 31: Optimization
Examples
Always measure first!
These are general tips that in general improve performance. If your code is slow, it is always
important to profile it to figure out what parts are slow. Guessing is never enough. Improving the
execution speed of something that only takes up 1% of the execution time probably isn't worth the
effort. Look for the big time sinks.
To get somewhat accurate numbers, make sure the code you are optimizing is executed for at
least one second when profiling. If you spend 10% of the execution time in that function, make
sure the complete program execution takes up at least 10 seconds, and make sure you can run
the same exact data through the code multiple times, to get repeatable numbers.
ExProf is simple to get started with.
Read Optimization online: https://riptutorial.com/elixir/topic/6062/optimization
https://riptutorial.com/
68
Chapter 32: Pattern matching
Examples
Pattern matching functions
#You can use pattern matching to run different
#functions based on which parameters you pass
#This example uses pattern matching to start,
#run, and end a recursive function
defmodule Counter do
def count_to do
count_to(100, 0) #No argument, init with 100
end
def count_to(counter) do
count_to(counter, 0) #Initialize the recursive function
end
def count_to(counter, value) when value == counter do
#This guard clause allows me to check my arguments against
#expressions. This ends the recursion when the value matches
#the number I am counting to.
:ok
end
def count_to(counter, value) do
#Actually do the counting
IO.puts value
count_to(counter, value + 1)
end
end
Pattern matching on a map
%{username: username} = %{username: "John Doe", id: 1}
# username == "John Doe"
%{username: username, id: 2} = %{username: "John Doe", id: 1}
** (MatchError) no match of right hand side value: %{id: 1, username: "John Doe"}
Pattern matching on a list
You can also pattern match on Elixir Data Structures such as Lists.
Lists
Matching on a list is quite simple.
https://riptutorial.com/
69
[head | tail] = [1,2,3,4,5]
# head == 1
# tail == [2,3,4,5]
This works by matching the first (or more) elements in the list to the left hand side of the | (pipe)
and the rest of the list to the right hand side variable of the |.
We can also match on specific values of a list:
[1,2 | tail] = [1,2,3,4,5]
# tail = [3,4,5]
[4 | tail] = [1,2,3,4,5]
** (MatchError) no match of right hand side value: [1, 2, 3, 4, 5]
Binding multiple consecutive values on the left of the | is also allowed:
[a, b | tail] = [1,2,3,4,5]
# a == 1
# b == 2
# tail = [3,4,5]
Even more complex - we can match on a specific value, and match that against a variable:
iex(11)> [a = 1 | tail] = [1,2,3,4,5]
# a == 1
Get the sum of a list using pattern matching
defmodule Math do
# We start of by passing the sum/1 function a list of numbers.
def sum(numbers) do
do_sum(numbers, 0)
end
# Recurse over the list when it contains at least one element.
# We break the list up into two parts:
# head: the first element of the list
# tail: a list of all elements except the head
# Every time this function is executed it makes the list of numbers
# one element smaller until it is empty.
defp do_sum([head|tail], acc) do
do_sum(tail, head + acc)
end
# When we have reached the end of the list, return the accumulated sum
defp do_sum([], acc), do: acc
end
Anonymous functions
f = fn
{:a, :b} -> IO.puts "Tuple {:a, :b}"
https://riptutorial.com/
70
[] -> IO.puts "Empty list"
end
f.({:a, :b}) # Tuple {:a, :b}
f.([]) # Empty list
Tuples
{ a, b, c } = { "Hello", "World", "!" }
IO.puts a # Hello
IO.puts b # World
IO.puts c # !
# Tuples of different size won't match:
{ a, b, c } = { "Hello", "World" } # (MatchError) no match of right hand side value: {
"Hello", "World" }
Reading a File
Pattern matching is useful for an operation like file reading which returns a tuple.
If the file sample.txt contains This is a sample text, then:
{ :ok, file } = File.read("sample.txt")
# => {:ok, "This is a sample text"}
file
# => "This is a sample text"
Otherwise, if the file does not exist:
{ :ok, file } = File.read("sample.txt")
# => ** (MatchError) no match of right hand side value: {:error, :enoent}
{ :error, msg } = File.read("sample.txt")
# => {:error, :enoent}
Pattern matching anonymous functions
fizzbuzz = fn
(0, 0, _) -> "FizzBuzz"
(0, _, _) -> "Fizz"
(_, 0, _) -> "Buzz"
(_, _, x) -> x
end
my_function = fn(n) ->
fizzbuzz.(rem(n, 3), rem(n, 5), n)
end
https://riptutorial.com/
71
Read Pattern matching online: https://riptutorial.com/elixir/topic/1602/pattern-matching
https://riptutorial.com/
72
Chapter 33: Polymorphism in Elixir
Introduction
Polymorphism is the provision of a single interface to entities of different types. Basically, it allows
different data types respond to the same function. So, the same function shapes for different data
types to accomplish the same behavior. Elixir language has protocols to implement polymorphism
with a clean way.
Remarks
If you want to cover all data types you can define an implementation for Any data type. Lastly, if
you have time, check the source code of Enum and String.Char, which are good examples of
polymorphism in core Elixir.
Examples
Polymorphism with Protocols
Let's implement a basic protocol that converts Kelvin and Fahrenheit temperatures to Celsius.
defmodule Kelvin do
defstruct name: "Kelvin", symbol: "K", degree: 0
end
defmodule Fahrenheit do
defstruct name: "Fahrenheit", symbol: "°F", degree: 0
end
defmodule Celsius do
defstruct name: "Celsius", symbol: "°C", degree: 0
end
defprotocol Temperature do
@doc """
Convert Kelvin and Fahrenheit to Celsius degree
"""
def to_celsius(degree)
end
defimpl Temperature, for: Kelvin do
@doc """
Deduct 273.15
"""
def to_celsius(kelvin) do
celsius_degree = kelvin.degree - 273.15
%Celsius{degree: celsius_degree}
end
end
defimpl Temperature, for: Fahrenheit do
https://riptutorial.com/
73
@doc """
Deduct 32, then multiply by 5, then divide by 9
"""
def to_celsius(fahrenheit) do
celsius_degree = (fahrenheit.degree - 32) * 5 / 9
%Celsius{degree: celsius_degree}
end
end
Now, we implemented our converters for the Kelvin and Fahrenheit types. Let's make some
conversions:
iex> fahrenheit = %Fahrenheit{degree: 45}
%Fahrenheit{degree: 45, name: "Fahrenheit", symbol: "°F"}
iex> celsius = Temperature.to_celsius(fahrenheit)
%Celsius{degree: 7.22, name: "Celsius", symbol: "°C"}
iex> kelvin = %Kelvin{degree: 300}
%Kelvin{degree: 300, name: "Kelvin", symbol: "K"}
iex> celsius = Temperature.to_celsius(kelvin)
%Celsius{degree: 26.85, name: "Celsius", symbol: "°C"}
Let's try to convert any other data type which has no implementation for to_celsius function:
iex> Temperature.to_celsius(%{degree: 12})
** (Protocol.UndefinedError) protocol Temperature not implemented for %{degree: 12}
iex:11: Temperature.impl_for!/1
iex:15: Temperature.to_celsius/1
Read Polymorphism in Elixir online: https://riptutorial.com/elixir/topic/9519/polymorphism-in-elixir
https://riptutorial.com/
74
Chapter 34: Processes
Examples
Spawning a Simple Process
In the following example, the greet function inside Greeter module is run in a separate process:
defmodule Greeter do
def greet do
IO.puts "Hello programmer!"
end
end
iex> spawn(Greeter, :greet, [])
Hello
#PID<0.122.0>
Here #PID<0.122.0> is the process identifier for the spawned process.
Sending and Receiving Messages
defmodule Processes do
def receiver do
receive do
{:ok, val} ->
IO.puts "Received Value: #{val}"
_ ->
IO.puts "Received something else"
end
end
end
iex(1)> pid = spawn(Processes, :receiver, [])
#PID<0.84.0>
iex(2)> send pid, {:ok, 10}
Received Value: 10
{:ok, 10}
Recursion and Receive
Recursion can be used to receive multiple messages
defmodule Processes do
def receiver do
receive do
{:ok, val} ->
IO.puts "Received Value: #{val}"
_ ->
IO.puts "Received something else"
end
https://riptutorial.com/
75
receiver
end
end
iex(1)> pid = spawn Processes, :receiver, []
#PID<0.95.0>
iex(2)> send pid, {:ok, 10}
Received Value: 10
{:ok, 10}
iex(3)> send pid, {:ok, 42}
{:ok, 42}
Received Value: 42
iex(4)> send pid, :random
:random
Received something else
Elixir will use a tail-call recursion optimisation as long as the function call is the last thing that
happens in the function as it is in the example.
Read Processes online: https://riptutorial.com/elixir/topic/3173/processes
https://riptutorial.com/
76
Chapter 35: Protocols
Remarks
A note on structs
Instead of sharing protocol implementation with maps, structs require their own protocol
implementation.
Examples
Introduction
Protocols enable polymorphism in Elixir. Define protocols with defprotocol:
defprotocol Log do
def log(value, opts)
end
Implement a protocol with defimpl:
require Logger
# User and Post are custom structs
defimpl Log, for: User do
def log(user, _opts) do
Logger.info "User: #{user.name}, #{user.age}"
end
end
defimpl Log, for: Post do
def log(user, _opts) do
Logger.info "Post: #{post.title}, #{post.category}"
end
end
With the above implementations, we can do:
iex> Log.log(%User{name: "Yos", age: 23})
22:53:11.604 [info] User: Yos, 23
iex> Log.log(%Post{title: "Protocols", category: "Protocols"})
22:53:43.604 [info] Post: Protocols, Protocols
Protocols let you dispatch to any data type, so long as it implements the protocol. This includes
some built-in types such as Atom, BitString, Tuples, and others.
Read Protocols online: https://riptutorial.com/elixir/topic/3487/protocols
https://riptutorial.com/
77
Chapter 36: Sigils
Examples
Build a list of strings
iex> ~w(a b c)
["a", "b", "c"]
Build a list of atoms
iex> ~w(a b c)a
[:a, :b, :c]
Custom sigils
Custom sigils can be made by creating a method sigil_X where X is the letter you want to use
(this can only be a single letter).
defmodule Sigils do
def sigil_j(string, options) do
# Split on the letter p, or do something more useful
String.split string, "p"
end
# Use this sigil in this module, or import it to use it elsewhere
end
The options argument is a binary of the arguments given at the end of the sigil, for example:
~j/foople/abc # string is "foople", options are 'abc'
# ["foo", "le"]
Read Sigils online: https://riptutorial.com/elixir/topic/2204/sigils
https://riptutorial.com/
78
Chapter 37: State Handling in Elixir
Examples
Managing a piece of state with an Agent
The simplest way to wrap and access a piece of state is Agent. The module allows one to spawn a
process that keeps an arbitrary data structure and allows one to send messages to read and
update that structure. Thanks to this the access to the structure is automatically serialized, as the
process only handles one message at a time.
iex(1)> {:ok, pid} = Agent.start_link(fn -> :initial_value end)
{:ok, #PID<0.62.0>}
iex(2)> Agent.get(pid, &(&1))
:initial_value
iex(3)> Agent.update(pid, fn(value) -> {value, :more_data} end)
:ok
iex(4)> Agent.get(pid, &(&1))
{:initial_value, :more_data}
Read State Handling in Elixir online: https://riptutorial.com/elixir/topic/6596/state-handling-in-elixir
https://riptutorial.com/
79
Chapter 38: Stream
Remarks
Streams are composable, lazy enumerables.
Due to their laziness, streams are useful when working with large (or even infinite) collections.
When chaining many operations with Enum, intermediate lists are created, while Stream creates a
recipe of computations that are executed at a later moment.
Examples
Chaining multiple operations
Stream is especially useful when you want to run multiple operations on a collection. This is
because Stream is lazy and only does one iteration (whereas Enum would do multiple iterations, for
example).
numbers = 1..100
|> Stream.map(fn(x) -> x * 2 end)
|> Stream.filter(fn(x) -> rem(x, 2) == 0 end)
|> Stream.take_every(3)
|> Enum.to_list
[2, 8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, 80, 86, 92, 98, 104, 110,
116, 122, 128, 134, 140, 146, 152, 158, 164, 170, 176, 182, 188, 194, 200]
Here, we chained 3 operations (map, filter and take_every), but the final iteration was only done
after Enum.to_list was called.
What Stream does internally, is that it waits until actual evaluation is required. Before that, it creates
a list of all the functions, but once evaluation is needed, it does goes through the collection once,
running all the functions on every item. This makes it more efficient than Enum, which in this case
would do 3 iterations, for example.
Read Stream online: https://riptutorial.com/elixir/topic/2553/stream
https://riptutorial.com/
80
Chapter 39: Strings
Remarks
A String in Elixir is a UTF-8 encoded binary.
Examples
Convert to string
Use Kernel.inspect to convert anything to string.
iex> Kernel.inspect(1)
"1"
iex> Kernel.inspect(4.2)
"4.2"
iex> Kernel.inspect %{pi: 3.14, name: "Yos"}
"%{pi: 3.14, name: \"Yos\"}"
Get a substring
iex> my_string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
iex> String.slice my_string, 6..10
"ipsum"
Split a string
iex> String.split("Elixir, Antidote, Panacea", ",")
["Elixir", "Antidote", "Panacea"]
String Interpolation
iex(1)> name = "John"
"John"
iex(2)> greeting = "Hello, #{name}"
"Hello, John"
iex(3)> num = 15
15
iex(4)> results = "#{num} item(s) found."
"15 item(s) found."
Check if String contains Substring
iex(1)> String.contains? "elixir of life", "of"
true
iex(2)> String.contains? "elixir of life", ["life", "death"]
true
https://riptutorial.com/
81
iex(3)> String.contains? "elixir of life", ["venus", "mercury"]
false
Join Strings
You can concatenate strings in Elixir using the <> operator:
"Hello" <> "World" # => "HelloWorld"
For a List of Strings, you can use Enum.join/2:
Enum.join(["A", "few", "words"], " ") # => "A few words"
Read Strings online: https://riptutorial.com/elixir/topic/2618/strings
https://riptutorial.com/
82
Chapter 40: Task
Syntax
•
•
Task.async(fun)
Task.await(task)
Parameters
Parameter Details
fun
task
The function that should be executed in a separate process.
The task returned by Task.async.
Examples
Doing work in the background
task = Task.async(fn -> expensive_computation end)
do_something_else
result = Task.await(task)
Parallel processing
crawled_site = ["http://www.google.com", "http://www.stackoverflow.com"]
|> Enum.map(fn site -> Task.async(fn -> crawl(site) end) end)
|> Enum.map(&Task.await/1)
Read Task online: https://riptutorial.com/elixir/topic/7588/task
https://riptutorial.com/
83
Chapter 41: Tips and Tricks
Introduction
Elixir Advanced tips and tricks which save our time while coding.
Examples
Creating Custom Sigils and Documenting
Each x sigil call respective sigil_x definition
Defining Custom Sigils
defmodule MySigils do
#returns the downcasing string if option l is given then returns the list of downcase
letters
def sigil_l(string,[]), do: String.Casing.downcase(string)
def sigil_l(string,[?l]), do: String.Casing.downcase(string) |> String.graphemes
#returns the upcasing string if option l is given then returns the list of downcase letters
def sigil_u(string,[]), do: String.Casing.upcase(string)
def sigil_u(string,[?l]), do: String.Casing.upcase(string) |> String.graphemes
end
Multiple [ OR ]
This is just the other way of writing Multiple OR conditions. This is not the recommended approach
because in regular approach when the condition evaluates to true, it stops executing the remaining
conditions which save the time of evaluation, unlike this approach which evaluates all conditions
first in the list. This is just bad but good for discoveries.
# Regular Approach
find = fn(x) when x>10 or x<5 or x==7 -> x end
# Our Hack
hell = fn(x) when true in [x>10,x<5,x==7] -> x end
iex Custom Configuration - iex Decoration
Copy the content into a file and save the file as .iex.exs in your ~ home directory and see the
magic. You can also download the file HERE
# IEx.configure colors: [enabled: true]
# IEx.configure colors: [ eval_result: [ :cyan, :bright ] ]
IO.puts IO.ANSI.red_background() <> IO.ANSI.white() <> " ❄❄❄ Good Luck with Elixir ❄❄❄ " <> IO.ANSI.reset
Application.put_env(:elixir, :ansi_enabled, true)
IEx.configure(
https://riptutorial.com/
84
colors: [
eval_result: [:green, :bright] ,
eval_error: [[:red,:bright,"Bug Bug ..!!"]],
eval_info: [:yellow, :bright ],
],
default_prompt: [
"\e[G", # ANSI CHA, move cursor to column 1
:white,
"I",
:red,
"❤" , # plain string
:green,
"%prefix",:white,"|",
:blue,
"%counter",
:white,
"|",
:red,
"▶" , # plain string
:white,
"▶▶" , # plain string
# ❤ ❤-»" , # plain string
:reset
] |> IO.ANSI.format |> IO.chardata_to_string
)
Read Tips and Tricks online: https://riptutorial.com/elixir/topic/10623/tips-and-tricks
https://riptutorial.com/
85
Credits
S.
No
Chapters
Contributors
Getting started with
Elixir Language
alejosocorro, Andrey Chernykh, Ben Bals, Community, cwc,
Delameko, Douglas Correa, helcim, I Am Batman, JAlberto,
koolkat, leifg, MattW., rap-2-h, Simone Carletti, Stephan
Rodemeier, Vinicius Quaiato, Yedhu Krishnan, Zimm i48
Basic .gitignore for
elixir program
Yos Riady
basic use of guard
clauses
alxndr
BEAM
Yos Riady
Behaviours
Yos Riady
Better debugging
with IO.inspect and
labels
leifg
Built-in types
Conditionals
Andrey Chernykh, Arithmeticbird, Oskar, TreyE, Vinicius
Quaiato
Andrey Chernykh, evuez, javanut13, Musfiqur Rahman, Paweł
Obrok
Constants
ibgib
1
2
3
4
5
6
7
8
9
10 Data Structures
Sam Mercier, Simone Carletti, Stephan Rodemeier, Yos Riady
11 Debugging Tips
javanut13, Paweł Obrok, Pfitz, Philippe-Arnaud de MANGOU,
sbs
12 Doctests
aholt, milmazz, Philippe-Arnaud de MANGOU, Yos Riady
13 Ecto
14 Erlang
15 ExDoc
16 ExUnit
fgutierr, Philippe-Arnaud de MANGOU, toraritte
4444, Yos Riady
milmazz, Yos Riady
Yos Riady
17
Functional
Dinesh Balasubramanian
https://riptutorial.com/
86
programming in Elixir
18
Functions
Andrey Chernykh, cwc, Dair, Eiji, Filip Haglund, PatNowak,
rainteller, Simone Carletti, Stephan Rodemeier, Yedhu Krishnan
, Yos Riady
19
20
Getting help in IEx
console
helcim
IEx Console Tips &
Tricks
alxndr, Cifer, fahrradflucht, legoscia, mudasobwa, muttonlamb,
PatNowak, Paweł Obrok, sbs, Sheharyar, Simone Carletti,
Stephan Rodemeier, Uniaika, Vincent, Yos Riady
21
Installation
cwc, Douglas Correa, Eiji, JAlberto, MattW.
22
Join Strings
Agung Santoso
23
Lists
Ben Bals, Candy Gumdrop, emoragaf, PatNowak, Sheharyar,
Yos Riady
24
Maps and Keyword
Lists
Sam Mercier, Simone Carletti, Yos Riady
25 Metaprogramming
4444, Paweł Obrok
26 Mix
4444, helcim, rainteller, Slava.K, Yos Riady
27 Modules
Alex G, javanut13, Yos Riady
28 Nodes
Yos Riady
29 Operators
alxndr, Andrey Chernykh, Dair, Gazler, Mitkins, nirev, PatNowak
30 Optimization
Filip Haglund, legoscia
31 Pattern matching
Alex Anderson, Dair, Danny Rosenblatt, evuez, Gabriel C, gmile
, Harrison Lucas, javanut13, Oskar, PatNowak, theIV, Thomas,
Yedhu Krishnan
32
Polymorphism in
Elixir
mustafaturan
33 Processes
Alex G, Yedhu Krishnan
34 Protocols
Yos Riady
35 Sigils
javanut13, Yos Riady
36
State Handling in
Elixir
Paweł Obrok
https://riptutorial.com/
87
37 Stream
Oskar
38 Strings
Alex G, Sheharyar, Yos Riady
39
Task
mario
40
Tips and Tricks
Ankanna
https://riptutorial.com/
88