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

The above program generates the following result −

Hello 
World!

Identifiers

Identifiers like variables, function names are used to identify a variable, function, etc. In Elixir, you can name your identifiers starting with a lower case alphabet with numbers, underscores and upper case letters thereafter. This naming convention is commonly known as snake_case. For example, following are some valid identifiers in Elixir −

var1       variable_2      one_M0r3_variable

Please note that variables can also be named with a leading underscore. A value that is not meant to be used must be assigned to _ or to a variable starting with underscore −

_some_random_value = 42

Also elixir relies on underscores to make functions private to modules. If you name a function with a leading underscore in a module, and import that module, this function will not be imported.

There are many more intricacies related to function naming in Elixir which we will discuss in coming chapters.

Reserved Words

Following words are reserved and cannot be used as variables, module or function names.

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

Elixir – Data Types

For using any language, you need to understand the basic data types the language supports. In this chapter, we will discuss 7 basic data types supported by the elixir language: integers, floats, Booleans, atoms, strings, lists and tuples.

Numerical Types

Elixir, like any other programming language, supports both integers and floats. If you open your elixir shell and input any integer or float as input, it”ll return its value. For example,

42

When the above program is run, it produces the following result −

42

You can also define numbers in octal, hex and binary bases.

Octal

To define a number in octal base, prefix it with ”0o”. For example, 0o52 in octal is equivalent to 42 in decimal.

Hexadecimal

To define a number in decimal base, prefix it with ”0x”. For example, 0xF1 in hex is equivalent to 241 in decimal.

Binary

To define a number in binary base, prefix it with ”0b”. For example, 0b1101 in binary is equivalent to 13 in decimal.

Elixir supports 64bit double precision for floating point numbers. And they can also be defined using an exponentiation style. For example, 10145230000 can be written as 1.014523e10

Atoms

Atoms are constants whose name is their value. They can be created using the color(:) symbol. For example,

:hello

Booleans

Elixir supports true and false as Booleans. Both these values are in fact attached to atoms :true and :false respectively.

Strings

Strings in Elixir are inserted between double quotes, and they are encoded in UTF-8. They can span multiple lines and contain interpolations. To define a string simply enter it in double quotes −

"Hello world"

To define multiline strings, we use a syntax similar to python with triple double quotes −

"""
Hello
World!
"""

We”ll learn about strings, binaries and char lists(similar to strings) in depth in the strings chapter.

Binaries

Binaries are sequences of bytes enclosed in << >> separated with a comma. For example,

<< 65, 68, 75>>

Binaries are mostly used to handle bits and bytes related data, if you have any. They can, by default, store 0 to 255 in each value. This size limit can be increased by using the size function that says how many bits it should take to store that value. For example,

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

Lists

Elixir uses square brackets to specify a list of values. Values can be of any type. For example,

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

Lists come with inbuilt functions for head and tail of the list named hd and tl which return the head and tail of the list respectively. Sometimes when you create a list, it”ll return a char list. This is because when elixir sees a list of printable ASCII characters, it prints it as a char list. Please note that strings and char lists are not equal. We”ll discuss lists further in later chapters.

Tuples

Elixir uses curly brackets to define tuples. Like lists, tuples can hold any value.

{ 1, "Hello", :an_atom, true 

A question arises here, – why provide both lists and tuples when they both work in the same way? Well they have different implementations.

• Lists are actually stored as linked lists, so insertions, deletions are very fast in lists.

• Tuples on the other hand, are stored in contiguous memory block, which make accessing them faster but adds an additional cost on insertions and deletions.

Elixir – Variables

A variable provides us with named storage that our programs can manipulate. Each variable in Elixir has a specific type, which determines the size and layout of the variable”s memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

Types of Variables

Elixir supports the following basic types of variables.

Integer

These are used for Integers. They are of size 32bit on a 32bit architecture and 64 bits on a 64-bit architecture. Integers are always signed in elixir. If an integer starts to expand in size above its limit, elixir convers it in a Big Integer which takes up memory in range 3 to n words whichever can fit it in memory.

Floats

Floats have a 64-bit precision in elixir. They are also like integers in terms of memory. When defining a float, exponential notation can be used.

Boolean

They can take up 2 values which is either true or false.

Strings

Strings are utf-8 encoded in elixir. They have a strings module which provides a lot of functionality to the programmer to manipulate strings.

Anonymous Functions/Lambdas

These are functions that can be defined and assigned to a variable, which can then be used to call this function.

Collections

There are a lot of collection types available in Elixir. Some of them are Lists, Tuples, Maps, Binaries, etc. These will be discussed in subsequent chapters.

Variable Declaration

A variable declaration tells the interpreter where and how much to create the storage for the variable. Elixir does not allow us to just declare a variable. A variable must be declared and assigned a value at the same time. For example, to create a variable named life and assign it a value 42, we do the following −

life = 42

This will bind the variable life to value 42. If we want to reassign this variable a new value, we can do this by using the same syntax as above, i.e.,

life = "Hello world"

Variable Naming

Naming variables follow a snake_case convention in Elixir, i.e., all variables must start with a lowercase letter, followed by 0 or more letters(both upper and lower case), followed at the end by an optional ”?” OR ”!”.

Variable names can also be started with a leading underscore but that must be used only when ignoring the variable, i.e., that variable will not be used again but is needed to be assigned to something.

Printing Variables

In the interactive shell, variables will print if you just enter the variable name. For example, if you create a variable −

life = 42 

And enter ”life” in your shell, you”ll get the output as −

42

But if you want to output a variable to the console (When running an external script from a file), you need to provide the variable as input to IO.puts function −

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)

A
B