IO.puts("Hello"); IO.puts("World!")

Вышеуказанная программа генерирует следующий результат —

Hello 
World!

Идентификаторы

Идентификаторы, такие как переменные, имена функций, используются для идентификации переменной, функции и т. Д. В Elixir вы можете называть свои идентификаторы, начиная с букв нижнего регистра с цифрами, подчеркиваниями и заглавными буквами после них. Это соглашение об именах широко известно как snake_case. Например, ниже приведены некоторые действительные идентификаторы в Elixir —

var1       variable_2      one_M0r3_variable

Обратите внимание, что переменные также могут быть названы с начальным подчеркиванием. Значение, которое не предназначено для использования, должно быть присвоено _ или переменной, начинающейся с подчеркивания —

_some_random_value = 42

Также elixir опирается на подчеркивания, чтобы сделать функции приватными для модулей. Если вы назовете функцию с начальным подчеркиванием в модуле и импортируете этот модуль, эта функция не будет импортирована.

В Elixir есть еще много тонкостей, связанных с именованием функций, которые мы обсудим в следующих главах.

Зарезервированные слова

Следующие слова зарезервированы и не могут использоваться в качестве переменных, имен модулей или функций.

after     and     catch     do     inbits     inlist     nil     else     end 
not     or     false     fn     in     rescue     true     when     xor 
__MODULE__    __FILE__    __DIR__    __ENV__    __CALLER__ 

Эликсир — Типы данных

Для использования любого языка вам необходимо понимать основные типы данных, которые поддерживает этот язык. В этой главе мы обсудим 7 основных типов данных, поддерживаемых языком эликсира: целые числа, числа с плавающей точкой, логические значения, атомы, строки, списки и кортежи.

Числовые Типы

Elixir, как и любой другой язык программирования, поддерживает как целые числа, так и числа с плавающей точкой. Если вы откроете оболочку elixir и введете любое целое число или число с плавающей запятой в качестве входных данных, она вернет свое значение. Например,

42

Когда вышеуказанная программа запущена, она дает следующий результат —

42

Вы также можете определить числа в восьмеричном, шестнадцатеричном и двоичном основаниях.

восьмеричный

Чтобы определить число в восьмеричной базе, поставьте перед ним «0o». Например, 0o52 в восьмеричном эквиваленте равно 42 в десятичном.

шестнадцатеричный

Чтобы определить число в десятичной базе, добавьте к нему префикс «0x». Например, 0xF1 в шестнадцатеричном формате эквивалентно 241 в десятичном виде.

двоичный

Чтобы определить число в двоичной базе, добавьте к нему префикс «0b». Например, 0b1101 в двоичном коде эквивалентно 13 в десятичном виде.

Elixir поддерживает 64-битную двойную точность для чисел с плавающей запятой. И они также могут быть определены с использованием стиля возведения в степень. Например, 10145230000 можно записать как 1.014523e10

атомы

Атомы — это константы, чье имя является их ценностью. Их можно создать с помощью символа цвета (:). Например,

:hello

Булевы

Эликсир поддерживает true и false как Booleans. Оба эти значения на самом деле привязаны к атомам: true и: false соответственно.

Струны

Строки в Elixir вставляются между двойными кавычками и кодируются в UTF-8. Они могут занимать несколько строк и содержать интерполяции. Чтобы определить строку, просто введите ее в двойных кавычках —

"Hello world"

Для определения многострочных строк мы используем синтаксис, похожий на python, с тройными двойными кавычками —

"""
Hello
World!
"""

Мы подробно узнаем о строках, двоичных файлах и списках символов (аналогично строкам) в главе о строках.

Бинарные

Двоичные файлы — это последовательности байтов, заключенные в << >>, разделенные запятой. Например,

<< 65, 68, 75>>

Двоичные файлы в основном используются для обработки данных, связанных с битами и байтами, если они у вас есть. По умолчанию они могут хранить от 0 до 255 в каждом значении. Этот предел размера может быть увеличен с помощью функции размера, которая сообщает, сколько битов нужно взять, чтобы сохранить это значение. Например,

<<65, 255, 289::size(15)>>

Списки

Elixir использует квадратные скобки для указания списка значений. Значения могут быть любого типа. Например,

[1, "Hello", :an_atom, true]

Списки поставляются со встроенными функциями для заголовка и хвоста списка с именами hd и tl, которые возвращают заголовок и хвост списка соответственно. Иногда, когда вы создаете список, он возвращает список символов. Это потому, что когда elixir видит список печатных символов ASCII, он печатает его как список символов. Обратите внимание, что строки и списки символов не равны. Мы обсудим списки в следующих главах.

Кортеж

Elixir использует фигурные скобки для определения кортежей. Как и списки, кортежи могут содержать любое значение.

{ 1, "Hello", :an_atom, true 

Здесь возникает вопрос: зачем указывать списки и кортежи, если они работают одинаково? Ну, у них есть разные реализации.

• Списки на самом деле хранятся в виде связанных списков, поэтому вставки, удаления в списках выполняются очень быстро.

• Кортежи, с другой стороны, хранятся в непрерывном блоке памяти, что ускоряет доступ к ним, но увеличивает затраты на вставки и удаления.

Списки на самом деле хранятся в виде связанных списков, поэтому вставки, удаления в списках выполняются очень быстро.

Кортежи, с другой стороны, хранятся в непрерывном блоке памяти, что ускоряет доступ к ним, но увеличивает затраты на вставки и удаления.

Эликсир — Переменные

Переменная предоставляет нам именованное хранилище, которым наши программы могут манипулировать. Каждая переменная в Elixir имеет определенный тип, который определяет размер и расположение памяти переменной; диапазон значений, которые могут быть сохранены в этой памяти; и набор операций, которые могут быть применены к переменной.

Типы переменных

Elixir поддерживает следующие основные типы переменных.

целое число

Они используются для целых чисел. Они имеют размер 32 бита в 32-битной архитектуре и 64 бита в 64-битной архитектуре. Целые числа всегда подписываются в эликсире. Если целое число начинает увеличиваться в размере, превышающем его предел, эликсир переводит его в большое целое число, которое занимает память в диапазоне от 3 до n слов, в зависимости от того, что может поместиться в памяти.

Поплавки

Поплавки имеют 64-битную точность в эликсире. Они также как целые числа с точки зрения памяти. При определении числа с плавающей запятой можно использовать экспоненциальную запись.

логический

Они могут принимать 2 значения, которые являются либо истиной, либо ложью.

Струны

Строки utf-8 закодированы в эликсире. У них есть модуль строк, который предоставляет программисту множество функций для работы со строками.

Анонимные функции / Лямбды

Это функции, которые можно определить и присвоить переменной, которую затем можно использовать для вызова этой функции.

Коллекции

Есть много типов коллекций, доступных в эликсире. Некоторые из них — это списки, кортежи, карты, двоичные файлы и т. Д. Они будут обсуждаться в последующих главах.

Объявление переменной

Объявление переменной сообщает интерпретатору, где и сколько нужно создать хранилище для переменной. Эликсир не позволяет нам просто объявить переменную. Переменная должна быть объявлена ​​и ей присвоено значение одновременно. Например, чтобы создать переменную с именем life и присвоить ей значение 42, мы делаем следующее —

life = 42

Это свяжет срок службы переменной со значением 42. Если мы хотим переназначить эту переменную новым значением, мы можем сделать это, используя тот же синтаксис, что и выше, т.е.

life = "Hello world"

Именование переменных

Переменные именования следуют соглашению snake_case в Elixir, т. Е. Все переменные должны начинаться со строчной буквы, за которой следуют 0 или более букв (как в верхнем, так и в нижнем регистре), после которых в конце указывается необязательный ‘?’ ИЛИ ЖЕ ‘!’.

Имена переменных также могут начинаться с начального подчеркивания, но их следует использовать только при игнорировании переменной, т. Е. Эта переменная больше не будет использоваться, но ее необходимо присвоить чему-либо.

Переменные печати

В интерактивной оболочке переменные будут напечатаны, если вы просто введете имя переменной. Например, если вы создаете переменную —

life = 42 

И введите «жизнь» в вашей оболочке, вы получите вывод как —

42

Но если вы хотите вывести переменную на консоль (при запуске внешнего скрипта из файла), вам необходимо предоставить переменную в качестве входных данных для функции IO.puts —

Live Demo

life = 42  
IO.puts life 

life = 42 
IO.puts(life) 

42

false and raise("An error")  
#This won't raise an error as raise function wont get executed because of short
#circuiting nature of and operator

use Bitwise

x = 12
x = "Hello"
IO.puts(x)

[var_1, _unused_var, var_2] = [{"First variable"}, 25, "Second variable" ]
IO.puts(var_1)
IO.puts(var_2)

[_, [_, {a}]] = ["Random string", [:an_atom, {24}]]
IO.puts(a)

24

a = 25
b = 25
^a = b

str = "Hello world"

str = str = "Hello world" 
IO.puts(str)

Hello World

a = ""
if String.length(a) === 0 do
   IO.puts("a is an empty string")
end

a is an empty string

x = "Apocalypse" 
y = "X-men #{x}"
IO.puts(y)

X-men Apocalypse

x = "Dark"
y = "Knight"
z = x <> " " <> y
IO.puts(z)

Dark Knight

IO.puts(String.length("Hello"))

5

IO.puts(String.reverse("Elixir"))

rixilE

var_1 = "Hello world"
var_2 = "Hello Elixir"
if var_1 === var_2 do
   IO.puts("#{var_1} and #{var_2} are the same")
else
   IO.puts("#{var_1} and #{var_2} are not the same")
end

Hello world and Hello elixir are not the same.

IO.puts(String.match?("foo", ~r/foo/))
IO.puts(String.match?("bar", ~r/foo/))

true 
false

IO.puts("foo" =~ ~r/foo/)

true

<< 0, 1, 2, 3 >>

<< 239, 191, 191 >>

IO.puts(<< 0, 1 >> <> << 2, 3 >>)

<< 0, 1, 2, 3 >>

IO.puts(<< 256 >>) # truncated, it'll print << 0 >>
IO.puts(<< 256 :: size(16) >>) #Takes 16 bits/2 bytes, will print << 1, 0 >>

<< 0 >>
<< 1, 0 >>

IO.puts(<< 256 :: utf8 >>)

Ā

bs = << 1 :: size(1) >>
IO.puts(bs)
IO.puts(is_binary(bs))
IO.puts(is_bitstring(bs))

<< 1::size(1) >>
false
true

IO.puts('Hello')
IO.puts(is_list('Hello'))

Hello
true

IO.puts(is_list(to_char_list("hełło")))
IO.puts(is_binary(to_string ('hełło')))

true
true

[1, 2, true, 3]

IO.puts([104, 101, 108, 108, 111])

hello

IO.puts(is_list('Hello'))

true

IO.puts(length([1, 2, :true, "str"]))

4

IO.puts([1, 2, 3] ++ [4, 5, 6])
IO.puts([1, true, 2, false, 3, true] -- [true, false])

[1, 2, 3, 4, 5, 6]
[1, 2, 3, true]

list = [1, 2, 3]
IO.puts(hd(list))
IO.puts(tl(list))

1
[2, 3]

{:ok, "hello"}

IO.puts(tuple_size({:ok, "hello"}))

2

tuple = {:ok, "Hello"}
Tuple.append(tuple, :world)

tuple = {:bar, :baz}
new_tuple_1 = Tuple.insert_at(tuple, 0, :foo)
new_tuple_2 = put_elem(tuple, 1, :foobar)

list = [{:a, 1}, {:b, 2}]

list_1 = [{:a, 1}, {:b, 2}]
list_2 = [a: 1, b: 2]
IO.puts(list_1 == list_2)

true

list = [a: 1, b: 2]
IO.puts(list[:a])

1

kl = [a: 1, a: 2, b: 3] 
IO.puts(Keyword.get(kl, :a)) 
IO.puts(Keyword.get_values(kl)) 

1
[1, 2]

kl = [a: 1, a: 2, b: 3]
kl_new = Keyword.put_new(kl, :c, 5)
IO.puts(Keyword.get(kl_new, :c))

5

kl = [a: 1, a: 2, b: 3, c: 0]
kl = Keyword.delete_first(kl, :b)
kl = Keyword.delete(kl, :a)

IO.puts(Keyword.get(kl, :a))
IO.puts(Keyword.get(kl, :b))
IO.puts(Keyword.get(kl, :c))

0

map = %{:a => 1, 2 => :b}

map = %{:a => 1, 2 => :b}
IO.puts(map[:a])
IO.puts(map[2])

1
b

map = %{:a => 1, 2 => :b}
new_map = Dict.put_new(map, :new_val, "value") 
IO.puts(new_map[:new_val])

"value"

map = %{:a => 1, 2 => :b}
new_map = %{ map | a: 25}
IO.puts(new_map[:a])

25

%{:a => a} = %{:a => 1, 2 => :b}
IO.puts(a)

1

n = 1
map = %{n => :one}
%{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}

map = %{:a => 1, 2 => :b} 
IO.puts(map.a) 

map = %{:a => 1, 2 => :b}
IO.puts(map.a)

1

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

$ elixirc math.ex

IO.puts(Math.sum(1, 2))

3

defmodule Math do
   def sum(a, b) do
      a + b
   end
end
IO.puts(Math.sum(1, 2))

$ elixir math.exs

3

defmodule Foo do
   #Foo module code here
   defmodule Bar do
      #Bar module code here
   end
end

# Alias the module so it can be called as Bar instead of Foo.Bar
alias Foo.Bar, as: Bar

# Ensure the module is compiled and available (usually for macros)
require Foo

# Import functions from Foo so they can be called without the `Foo.` prefix
import Foo

# Invokes the custom code defined in Foo as an extension point
use Foo

alias String, as: Str
IO.puts(Str.length("Hello"))

5

alias List, as: String
#Now when we use String we are actually using List.
#To use the string module: 
IO.puts(Elixir.String.length("Hello"))

5

Integer.is_odd(3)

** (CompileError) iex:1: you must require Integer before invoking the macro Integer.is_odd/1

require Integer
Integer.is_odd(3)

import List, only: [duplicate: 2]

import Integer, only: :macros

defmodule Example do 
   use Feature, option: :value 
end 

defmodule Example do
   require Feature
   Feature.__using__(option: :value)
end

sum = fn (a, b) -> a + b end
IO.puts(sum.(1, 5))

6

sum = &(&1 + &2) 
IO.puts(sum.(1, 2))

3

handle_result = fn
   {var1} -> IO.puts("#{var1} found in a tuple!")
   {var_2, var_3} -> IO.puts("#{var_2} and #{var_3} found!")
end
handle_result.({"Hey people"})
handle_result.({"Hello", "World"})

Hey people found in a tuple!
Hello and World found!

def function_name(argument_1, argument_2) do
   #code to be executed when function is called
end

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

IO.puts(Math.sum(5, 6))

11

defmodule Math do
   def sum(a, b), do: a + b
end
IO.puts(Math.sum(5, 6))

11

defmodule Greeter do
   def hello(name), do: phrase <> name
   defp phrase, do: "Hello "
end

Greeter.hello("world")

Hello world

defmodule Greeter do
   def hello(name, country \\ "en") do
      phrase(country) <> name
   end

   defp phrase("en"), do: "Hello, "
   defp phrase("es"), do: "Hola, "
end

Greeter.hello("Ayush", "en")
Greeter.hello("Ayush")
Greeter.hello("Ayush", "es")

Hello, Ayush
Hello, Ayush
Hola, Ayush

defmodule Math do
   def fact(res, num) do
   if num === 1 do
      res
   else
      new_res = res * num
      fact(new_res, num-1)
      end
   end
end

IO.puts(Math.fact(1,5))

120

a = ["Hey", 100, 452, :true, "People"]
defmodule ListPrint do
   def print([]) do
   end
   def print([head | tail]) do 
      IO.puts(head)
      print(tail)
   end
end

ListPrint.print(a)

Hey
100
452
true
People

for(i = 0; i < 10; i++) {
   printf("%d", array[i]);
}

defmodule Loop do
   def print_multiple_times(msg, n) when n <= 1 do
      IO.puts msg
   end

   def print_multiple_times(msg, n) do
      IO.puts msg
      print_multiple_times(msg, n - 1)
   end
end

Loop.print_multiple_times("Hello", 10)

Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello

res = Enum.all?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end) 
IO.puts(res)

false

res = Enum.any?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end)
IO.puts(res)

true

res = Enum.chunk([1, 2, 3, 4, 5, 6], 2)
IO.puts(res)

[[1, 2], [3, 4], [5, 6]]

Enum.each(["Hello", "Every", "one"], fn(s) -> IO.puts(s) end)

Hello
Every
one

res = Enum.map([2, 5, 3, 6], fn(a) -> a*2 end)
IO.puts(res)

[4, 10, 6, 12]

res = Enum.reduce([1, 2, 3, 4], 5, fn(x, accum) -> x + accum end)
IO.puts(res)

15

res = Enum.reduce([1, 2, 3, 4], fn(x, accum) -> x + accum end)
IO.puts(res)

10

res = Enum.uniq([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
IO.puts(res)

[1, 2, 3, 4]

odd? = &(odd? = &(rem(&1, 2) != 0) 
res = 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum 
IO.puts(res) 

7500000000

Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))

odd? = &(rem(&1, 2) != 0)
res = 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum
IO.puts(res)

7500000000

defmodule User do
   defstruct name: "John", age: 27
end

new_john = %User{})
ayush = %User{name: "Ayush", age: 20}
megan = %User{name: "Megan"})

%User{age: 27, name: "John"}
%User{age: 20, name: "Ayush"}
%User{age: 27, name: "Megan"}

defmodule User do
   defstruct name: "John", age: 27
end
john = %User{}
#john right now is: %User{age: 27, name: "John"}

#To access name and age of John, 
IO.puts(john.name)
IO.puts(john.age)

John
27

meg = %{john | name: "Meg"}

defprotocol Blank do
   def blank?(data)
end

#Defining the protocol
defprotocol Blank do
   def blank?(data)
end

#Implementing the protocol for lists
defimpl Blank, for: List do
   def blank?([]), do: true
   def blank?(_), do: false
end

#Implementing the protocol for strings
defimpl Blank, for: BitString do
   def blank?(""), do: true
   def blank?(_), do: false
end

#Implementing the protocol for maps
defimpl Blank, for: Map do
   def blank?(map), do: map_size(map) == 0
end

IO.puts(Blank.blank? [])
IO.puts(Blank.blank? [:true, "Hello"])
IO.puts(Blank.blank? "")
IO.puts(Blank.blank? "Hi")

true
false
true
false

IO.puts(Path.join("foo", "bar"))

foo/bar

{:ok, file} = File.read("newfile", [:write]) 
# Pattern matching to store returned stream
IO.binwrite(file, "This will be written to the file")

This will be written to the file 

{:ok, file} = File.open("newfile")
file = File.open!("newfile")

file = File.open!("newfile", [:read, :utf8])

File.write("newfile", "Hello")

#Open the file in read, write and utf8 modes. 
file = File.open!("newfile_2", [:read, :utf8, :write])

#Write to this "io_device" using standard IO functions
IO.puts(file, "Random text")

IO.puts(File.read("newfile"))

File.close(file)

pid = spawn(fn -> 2 * 2 end)
Process.alive?(pid)

false

pid = self
 
Process.alive?(pid)

true

send(self(), {:hello, "Hi people"})

receive do
   {:hello, msg} -> IO.puts(msg)
   {:another_case, msg} -> IO.puts("This one won't match!")
end

Hi people

receive do
   {:hello, msg}  -> msg
after
   1_000 -> "nothing after 1s"
end

nothing after 1s

spawn fn -> raise "oops" end

[error] Process #PID<0.58.00> raised an exception
** (RuntimeError) oops
   :erlang.apply/2

spawn_link fn -> raise "oops" end

** (EXIT from #PID<0.41.0>) an exception was raised:
   ** (RuntimeError) oops
      :erlang.apply/2

defmodule KV do
   def start_link do
      Task.start_link(fn -> loop(%{}) end)
   end

   defp loop(map) do
      receive do
         {:get, key, caller} ->
         send caller, Map.get(map, key)
         loop(map)
         {:put, key, value} ->
         loop(Map.put(map, key, value))
      end
   end
end

iex kv.exs

{:ok, pid} = KV.start_link

# pid now has the pid of our new process that is being 
# used to get and store key value pairs 

# Send a KV pair :hello, "Hello" to the process
send pid, {:put, :hello, "Hello"}

# Ask for the key :hello
send pid, {:get, :hello, self()}

# Print all the received messages on the current process.
flush()

"Hello"

# A regular expression that matches strings which contain "foo" or
# "bar":
regex = ~r/foo|bar/
IO.puts("foo" =~ regex)
IO.puts("baz" =~ regex)

true
false

~r/hello/
~r|hello|
~r"hello"
~r'hello'
~r(hello)
~r[hello]
~r{hello}
~r<hello>

new_string = ~s(this is a string with "double" quotes, not 'single' ones)
IO.puts(new_string)

"this is a string with \"double\" quotes, not 'single' ones"

new_char_list = ~c(this is a char list containing 'single quotes')
IO.puts(new_char_list)

this is a char list containing 'single quotes'

new_word_list = ~w(foo bar bat)
IO.puts(new_word_list)

foobarbat

new_atom_list = ~w(foo bar bat)a
IO.puts(new_atom_list)

[:foo, :bar, :bat]

~s(String with escape codes \x26 #{"inter" <> "polation"})
# "String with escape codes & interpolation"
~S(String without escape codes \x26 without #{interpolation})
# "String without escape codes \\x26 without \#{interpolation}"

defmodule CustomSigil do
   def sigil_u(string, []), do: String.upcase(string)
end

import CustomSigil

IO.puts(~u/tutorials point/)

TUTORIALS POINT

Enum.map(1..3, &(&1 * 2))

for n <- 1..3, do: n * 2

[2, 4, 6]

import Integer
IO.puts(for x <- 1..10, is_even(x), do: x)

[2, 4, 6, 8, 10]

IO.puts(for <<c <- " hello world ">>, c != ?\s, into: "", do: <<c>>)

helloworld

round(number) :: integer

@spec round(number) :: integer
def round(number), do: # Function implementation
...

defmodule FunnyCalculator do
   @type number_with_joke :: {number, String.t}

   @spec add(number, number) :: number_with_joke
   def add(x, y), do: {x + y, "You need a calculator to do that?"}

   @spec multiply(number, number) :: number_with_joke
   def multiply(x, y), do: {x * y, "It is like addition on steroids."}
end

{result, comment} = FunnyCalculator.add(10, 20)
IO.puts(result)
IO.puts(comment)

30
You need a calculator to do that?

defmodule GreetBehaviour do
   @callback say_hello(name :: string) :: nil
   @callback say_bye(name :: string) :: nil
end

defmodule GreetBehaviour do
   @callback say_hello(name :: string) :: nil
   @callback say_bye(name :: string) :: nil
end

defmodule EnglishGreet do
   @behaviour GreetBehaviour
   def say_hello(name), do: IO.puts("Hello " <> name)
   def say_bye(name), do: IO.puts("Goodbye, " <> name)
end

defmodule SpanishGreet do
   @behaviour GreetBehaviour
   def say_hello(name), do: IO.puts("Hola " <> name)
   def say_bye(name), do: IO.puts("Adios " <> name)
end

EnglishGreet.say_hello("Ayush")
EnglishGreet.say_bye("Ayush")
SpanishGreet.say_hello("Ayush")
SpanishGreet.say_bye("Ayush")

Hello Ayush
Goodbye, Ayush
Hola Ayush
Adios Ayush

IO.puts(1 + "Hello")

** (ArithmeticError) bad argument in arithmetic expression
   :erlang.+(1, "Hello")

#Runtime Error with just a message
raise "oops"  # ** (RuntimeError) oops

#Other error type with a message
raise ArgumentError, message: "invalid argument foo"

defmodule MyError do
   defexception message: "default message"
end

raise MyError  # Raises error with default message
raise MyError, message: "custom message"  # Raises error with custom message

err = try do
   raise "oops"
rescue
   e in RuntimeError -> e
end

IO.puts(err.message)

oops

err = try do
   1 + "Hello"
rescue
   RuntimeError -> "You've got a runtime error!"
   ArithmeticError -> "You've got a Argument error!"
end

IO.puts(err)

You've got a Argument error!

val = try do
   Enum.each 20..100, fn(x) ->
      if rem(x, 13) == 0, do: throw(x)
   end
   "Got nothing"
catch
   x -> "Got #{x}"
end

IO.puts(val)

Got 26

spawn_link fn -> exit(1) end

val = try do
   exit "I am exiting"
catch
   :exit, _ -> "not really"
end

IO.puts(val)

not really

{:ok, file} = File.open "sample", [:utf8, :write]
try do
   IO.write file, "olá"
   raise "oops, something went wrong"
after
   File.close(file)
end

{:sum, [], [1, 2, 3]}

quote do: sum(1, 2, 3)

num = 25

quote do: sum(15, num)

quote do: sum(15, unquote(num))

{:sum, [], [15, {:num, [], Elixir}]}
{:sum, [], [15, 25]} 

defmodule OurMacro do
   defmacro unless(expr, do: block) do
      quote do
         if !unquote(expr), do: unquote(block)
      end
   end
end

require OurMacro

OurMacro.unless true, do: IO.puts "True Expression"

OurMacro.unless false, do: IO.puts "False expression"

False expression 

# UTF-8
IO.puts(String.to_char_list("Ø"))

# binary
IO.puts(:binary.bin_to_list "Ø")

[216]
[195, 152]

IO.puts(Base.encode16(:crypto.hash(:sha256, "Elixir")))

3315715A7A3AD57428298676C5AE465DADA38D951BDFAC9348A8A31E9C7401CB

digraph = :digraph.new()
coords = [{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]
[v0, v1, v2] = (for c <- coords, do: :digraph.add_vertex(digraph, c))
:digraph.add_edge(digraph, v0, v1)
:digraph.add_edge(digraph, v1, v2)
for point <- :digraph.get_short_path(digraph, v0, v2) do 
   {x, y} = point
   IO.puts("#{x}, #{y}")
end

0.0, 0.0
1.0, 0.0
1.0, 1.0

# Value of pi
IO.puts(:math.pi())

# Logarithm
IO.puts(:math.log(7.694785265142018e23))

# Exponentiation
IO.puts(:math.exp(55.0))

#...

3.141592653589793
55.0
7.694785265142018e23

q = :queue.new
q = :queue.in("A", q)
q = :queue.in("B", q)
{{:value, val}, q} = :queue.out(q)
IO.puts(val)
{{:value, val}, q} = :queue.out(q)
IO.puts(val)