# Original: https://learnxinyminutes.com/docs/elixir/

# Single line comments start with a number symbol.

# There's no multi-line comment,
# but you can stack multiple comments.

# To use the elixir shell use the `iex` command.
# Compile your modules with the `elixirc` command.

# Both should be in your path if you installed elixir correctly.

## ---------------------------
## -- Basic types
## ---------------------------

# There are numbers
3    # integer
0x1F # integer
3.0  # float

# Atoms, that are literals, a constant with name. They start with `:`.
:hello # atom

# Tuples that are stored contiguously in memory.
<beginfold id='1'>{</beginfold id='1'>1,2,3<endfold id='1'>}</endfold id='1'> # tuple

# We can access a tuple element with the `elem` function:
elem<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>1, 2, 3<endfold id='1'>}</endfold id='1'>, 0<endfold id='2'>)</endfold id='2'> #=> 1

# Lists that are implemented as linked lists.
<beginfold id='3'>[</beginfold id='3'>1,2,3<endfold id='3'>]</endfold id='3'> # list

# We can access the head and tail of a list as follows:
<beginfold id='3'>[</beginfold id='3'>head | tail<endfold id='3'>]</endfold id='3'> = <beginfold id='3'>[</beginfold id='3'>1,2,3<endfold id='3'>]</endfold id='3'>
head #=> 1
tail #=> [2,3]

# In elixir, just like in Erlang, the `=` denotes pattern matching and
# not an assignment.
#
# This means that the left-hand side (pattern) is matched against a
# right-hand side.
#
# This is how the above example of accessing the head and tail of a list works.

# A pattern match will error when the sides don't match, in this example
# the tuples have different sizes.
# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}

# There are also binaries
<<1,2,3>> # binary

# Strings and char lists
"hello" # string
'hello' # char list

# Multi-line strings
"""
I'm a multi-line
string.
"""
#=> "I'm a multi-line\nstring.\n"

# Strings are all encoded in UTF-8:
"héllò" #=> "héllò"

# Strings are really just binaries, and char lists are just lists.
<<?a, ?b, ?c>> #=> "abc"
<beginfold id='3'>[</beginfold id='3'>?a, ?b, ?c<endfold id='3'>]</endfold id='3'>   #=> 'abc'

# `?a` in elixir returns the ASCII integer for the letter `a`
?a #=> 97

# To concatenate lists use `++`, for binaries use `<>`
<beginfold id='3'>[</beginfold id='3'>1,2,3<endfold id='3'>]</endfold id='3'> ++ <beginfold id='3'>[</beginfold id='3'>4,5<endfold id='3'>]</endfold id='3'>     #=> [1,2,3,4,5]
'hello ' ++ 'world'  #=> 'hello world'

<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
"hello " <> "world"  #=> "hello world"

# Ranges are represented as `start..end` (both inclusive)
1..10 #=> 1..10
lower..upper = 1..10 # Can use pattern matching on ranges as well
<beginfold id='3'>[</beginfold id='3'>lower, upper<endfold id='3'>]</endfold id='3'> #=> [1, 10]

## ---------------------------
## -- Operators
## ---------------------------

# Some math
1 + 1  #=> 2
10 - 5 #=> 5
5 * 2  #=> 10
10 / 2 #=> 5.0

# In elixir the operator `/` always returns a float.

# To do integer division use `div`
div<beginfold id='2'>(</beginfold id='2'>10, 2<endfold id='2'>)</endfold id='2'> #=> 5

# To get the division remainder use `rem`
rem<beginfold id='2'>(</beginfold id='2'>10, 3<endfold id='2'>)</endfold id='2'> #=> 1

# There are also boolean operators: `or`, `and` and `not`.
# These operators expect a boolean as their first argument.
true and true #=> true
false or true #=> true
# 1 and true    #=> ** (ArgumentError) argument error

# Elixir also provides `||`, `&&` and `!` which accept arguments of any type.
# All values except `false` and `nil` will evaluate to true.
1 || true  #=> 1
false && 1 #=> false
nil && 20  #=> nil
!true #=> false

# For comparisons we have: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>`
1 == 1 #=> true
1 != 1 #=> false
1 < 2  #=> true

# `===` and `!==` are more strict when comparing integers and floats:
1 == 1.0  #=> true
1 === 1.0 #=> false

# We can also compare two different data types:
1 < :hello #=> true

# The overall sorting order is defined below:
# number < atom < reference < functions < port < pid < tuple < list < bit string

# To quote Joe Armstrong on this: "The actual order is not important,
# but that a total ordering is well defined is important."

## ---------------------------
## -- Control Flow
## ---------------------------

# `if` expression
if false <beginfold id='4'>do</beginfold id='4'>
  "This will never be seen"
else
  "This will"
<endfold id='4'>end</endfold id='4'>

# There's also `unless`
unless true <beginfold id='4'>do</beginfold id='4'>
  "This will never be seen"
else
  "This will"
<endfold id='4'>end</endfold id='4'>

# Remember pattern matching? Many control-flow structures in elixir rely on it.

# `case` allows us to compare a value against many patterns:
case <beginfold id='1'>{</beginfold id='1'>:one, :two<endfold id='1'>}</endfold id='1'> <beginfold id='4'>do</beginfold id='4'>
  <beginfold id='1'>{</beginfold id='1'>:four, :five<endfold id='1'>}</endfold id='1'> ->
    "This won't match"
  <beginfold id='1'>{</beginfold id='1'>:one, x<endfold id='1'>}</endfold id='1'> ->
    "This will match and bind `x` to `:two`"
  _ ->
    "This will match any value"
<endfold id='4'>end</endfold id='4'>

# It's common to bind the value to `_` if we don't need it.
# For example, if only the head of a list matters to us:
<beginfold id='3'>[</beginfold id='3'>head | _<endfold id='3'>]</endfold id='3'> = <beginfold id='3'>[</beginfold id='3'>1,2,3<endfold id='3'>]</endfold id='3'>
head #=> 1

# For better readability we can do the following:
<beginfold id='3'>[</beginfold id='3'>head | _tail<endfold id='3'>]</endfold id='3'> = <beginfold id='3'>[</beginfold id='3'>:a, :b, :c<endfold id='3'>]</endfold id='3'>
head #=> :a

# `cond` lets us check for many conditions at the same time.
# Use `cond` instead of nesting many `if` expressions.
cond <beginfold id='4'>do</beginfold id='4'>
  1 + 1 == 3 ->
    "I will never be seen"
  2 * 5 == 12 ->
    "Me neither"
  1 + 2 == 3 ->
    "But I will"
<endfold id='4'>end</endfold id='4'>

# It is common to set the last condition equal to `true`, which will always match.
cond <beginfold id='4'>do</beginfold id='4'>
  1 + 1 == 3 ->
    "I will never be seen"
  2 * 5 == 12 ->
    "Me neither"
  true ->
    "But I will (this is essentially an else)"
<endfold id='4'>end</endfold id='4'>

# `try/catch` is used to catch values that are thrown, it also supports an
# `after` clause that is invoked whether or not a value is caught.
try <beginfold id='4'>do</beginfold id='4'>
  throw<beginfold id='2'>(</beginfold id='2'>:hello<endfold id='2'>)</endfold id='2'>
catch
  message -> "Got #{message}."
after
  IO.puts<beginfold id='2'>(</beginfold id='2'>"I'm the after clause."<endfold id='2'>)</endfold id='2'>
<endfold id='4'>end</endfold id='4'>
#=> I'm the after clause
# "Got :hello"

## ---------------------------
## -- Modules and Functions
## ---------------------------

# Anonymous functions (notice the dot)
square = <beginfold id='4'>fn</beginfold id='4'><beginfold id='2'>(</beginfold id='2'>x<endfold id='2'>)</endfold id='2'> -> x * x <endfold id='4'>end</endfold id='4'>
square.<beginfold id='2'>(</beginfold id='2'>5<endfold id='2'>)</endfold id='2'> #=> 25

# They also accept many clauses and guards.
# Guards let you fine tune pattern matching,
# they are indicated by the `when` keyword:
f = <beginfold id='4'>fn</beginfold id='4'>
  x, y when x > 0 -> x + y
  x, y -> x * y
<endfold id='4'>end</endfold id='4'>

f.<beginfold id='2'>(</beginfold id='2'>1, 3<endfold id='2'>)</endfold id='2'>  #=> 4
f.<beginfold id='2'>(</beginfold id='2'>-1, 3<endfold id='2'>)</endfold id='2'> #=> -3

# Elixir also provides many built-in functions.
# These are available in the current scope.
is_number<beginfold id='2'>(</beginfold id='2'>10<endfold id='2'>)</endfold id='2'>    #=> true
is_list<beginfold id='2'>(</beginfold id='2'>"hello"<endfold id='2'>)</endfold id='2'> #=> false
elem<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>1,2,3<endfold id='1'>}</endfold id='1'>, 0<endfold id='2'>)</endfold id='2'> #=> 1

# You can group several functions into a module. Inside a module use `def`
# to define your functions.
defmodule Math <beginfold id='4'>do</beginfold id='4'>
  def sum<beginfold id='2'>(</beginfold id='2'>a, b<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    a + b
  <endfold id='4'>end</endfold id='4'>

  def square<beginfold id='2'>(</beginfold id='2'>x<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    x * x
  <endfold id='4'>end</endfold id='4'>
<endfold id='4'>end</endfold id='4'>

Math.sum<beginfold id='2'>(</beginfold id='2'>1, 2<endfold id='2'>)</endfold id='2'>  #=> 3
Math.square<beginfold id='2'>(</beginfold id='2'>3<endfold id='2'>)</endfold id='2'> #=> 9

# To compile our simple Math module save it as `math.ex` and use `elixirc`
# in your terminal: elixirc math.ex

# Inside a module we can define functions with `def` and private functions with `defp`.
# A function defined with `def` is available to be invoked from other modules,
# a private function can only be invoked locally.
defmodule PrivateMath <beginfold id='4'>do</beginfold id='4'>
  def sum<beginfold id='2'>(</beginfold id='2'>a, b<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    do_sum<beginfold id='2'>(</beginfold id='2'>a, b<endfold id='2'>)</endfold id='2'>
  <endfold id='4'>end</endfold id='4'>

  defp do_sum<beginfold id='2'>(</beginfold id='2'>a, b<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    a + b
  <endfold id='4'>end</endfold id='4'>
<endfold id='4'>end</endfold id='4'>

PrivateMath.sum<beginfold id='2'>(</beginfold id='2'>1, 2<endfold id='2'>)</endfold id='2'>    #=> 3
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)

# Function declarations also support guards and multiple clauses:
defmodule Geometry <beginfold id='4'>do</beginfold id='4'>
  def area<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>:rectangle, w, h<endfold id='1'>}</endfold id='1'><endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    w * h
  <endfold id='4'>end</endfold id='4'>

  def area<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>:circle, r<endfold id='1'>}</endfold id='1'><endfold id='2'>)</endfold id='2'> when is_number<beginfold id='2'>(</beginfold id='2'>r<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    3.14 * r * r
  <endfold id='4'>end</endfold id='4'>
<endfold id='4'>end</endfold id='4'>

Geometry.area<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>:rectangle, 2, 3<endfold id='1'>}</endfold id='1'><endfold id='2'>)</endfold id='2'> #=> 6
Geometry.area<beginfold id='2'>(</beginfold id='2'><beginfold id='1'>{</beginfold id='1'>:circle, 3<endfold id='1'>}</endfold id='1'><endfold id='2'>)</endfold id='2'>       #=> 28.25999999999999801048
# Geometry.area({:circle, "not_a_number"})
#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1

# Due to immutability, recursion is a big part of elixir
defmodule Recursion <beginfold id='4'>do</beginfold id='4'>
  def sum_list<beginfold id='2'>(</beginfold id='2'><beginfold id='3'>[</beginfold id='3'>head | tail<endfold id='3'>]</endfold id='3'>, acc<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    sum_list<beginfold id='2'>(</beginfold id='2'>tail, acc + head<endfold id='2'>)</endfold id='2'>
  <endfold id='4'>end</endfold id='4'>

  def sum_list<beginfold id='2'>(</beginfold id='2'><beginfold id='3'>[</beginfold id='3'><endfold id='3'>]</endfold id='3'>, acc<endfold id='2'>)</endfold id='2'> <beginfold id='4'>do</beginfold id='4'>
    acc
  <endfold id='4'>end</endfold id='4'>
<endfold id='4'>end</endfold id='4'>

Recursion.sum_list<beginfold id='2'>(</beginfold id='2'><beginfold id='3'>[</beginfold id='3'>1,2,3<endfold id='3'>]</endfold id='3'>, 0<endfold id='2'>)</endfold id='2'> #=> 6

# Elixir modules support attributes, there are built-in attributes and you
# may also add custom ones.
defmodule MyMod <beginfold id='4'>do</beginfold id='4'>
  @moduledoc """
  This is a built-in attribute on a example module.
  """

  @my_data 100 # This is a custom attribute.
  IO.inspect<beginfold id='2'>(</beginfold id='2'>@my_data<endfold id='2'>)</endfold id='2'> #=> 100
<endfold id='4'>end</endfold id='4'>

## ---------------------------
## -- Structs and Exceptions
## ---------------------------

# Structs are extensions on top of maps that bring default values,
# compile-time guarantees and polymorphism into Elixir.
defmodule Person <beginfold id='4'>do</beginfold id='4'>
  defstruct name: nil, age: 0, height: 0
<endfold id='4'>end</endfold id='4'>

joe_info = %Person<beginfold id='1'>{</beginfold id='1'> name: "Joe", age: 30, height: 180 <endfold id='1'>}</endfold id='1'>
#=> %Person{age: 30, height: 180, name: "Joe"}

# Access the value of name
joe_info.name #=> "Joe"

# Update the value of age
older_joe_info = %<beginfold id='1'>{</beginfold id='1'> joe_info | age: 31 <endfold id='1'>}</endfold id='1'>
#=> %Person{age: 31, height: 180, name: "Joe"}

# The `try` block with the `rescue` keyword is used to handle exceptions
try <beginfold id='4'>do</beginfold id='4'>
  raise "some error"
rescue
  RuntimeError -> "rescued a runtime error"
  _error -> "this will rescue any error"
<endfold id='4'>end</endfold id='4'>
#=> "rescued a runtime error"

# All exceptions have a message
try <beginfold id='4'>do</beginfold id='4'>
  raise "some error"
rescue
  x in <beginfold id='3'>[</beginfold id='3'>RuntimeError<endfold id='3'>]</endfold id='3'> ->
    x.message
<endfold id='4'>end</endfold id='4'>
#=> "some error"

## ---------------------------
## -- Concurrency
## ---------------------------

# Elixir relies on the actor model for concurrency. All we need to write
# concurrent programs in elixir are three primitives: spawning processes,
# sending messages and receiving messages.

# To start a new process we use the `spawn` function, which takes a function
# as argument.
f = <beginfold id='4'>fn</beginfold id='4'> -> 2 * 2 <endfold id='4'>end</endfold id='4'> #=> #Function<erl_eval.20.80484245>
spawn<beginfold id='2'>(</beginfold id='2'>f<endfold id='2'>)</endfold id='2'> #=> #PID<0.40.0>

# `spawn` returns a pid (process identifier), you can use this pid to send
# messages to the process. To do message passing we use the `send` operator.
# For all of this to be useful we need to be able to receive messages. This is
# achieved with the `receive` mechanism:

# The `receive do` block is used to listen for messages and process
# them when they are received. A `receive do` block will only
# process one received message. In order to process multiple
# messages, a function with a `receive do` block must recursively
# call itself to get into the `receive do` block again.

defmodule Geometry <beginfold id='4'>do</beginfold id='4'>
  def area_loop <beginfold id='4'>do</beginfold id='4'>
    receive <beginfold id='4'>do</beginfold id='4'>
      <beginfold id='1'>{</beginfold id='1'>:rectangle, w, h<endfold id='1'>}</endfold id='1'> ->
        IO.puts<beginfold id='2'>(</beginfold id='2'>"Area = #{w * h}"<endfold id='2'>)</endfold id='2'>
        area_loop<beginfold id='2'>(</beginfold id='2'><endfold id='2'>)</endfold id='2'>
      <beginfold id='1'>{</beginfold id='1'>:circle, r<endfold id='1'>}</endfold id='1'> ->
        IO.puts<beginfold id='2'>(</beginfold id='2'>"Area = #{3.14 * r * r}"<endfold id='2'>)</endfold id='2'>
        area_loop<beginfold id='2'>(</beginfold id='2'><endfold id='2'>)</endfold id='2'>
    <endfold id='4'>end</endfold id='4'>
  <endfold id='4'>end</endfold id='4'>
<endfold id='4'>end</endfold id='4'>

# Compile the module and create a process that evaluates `area_loop` in the shell
pid = spawn<beginfold id='2'>(</beginfold id='2'><beginfold id='4'>fn</beginfold id='4'> -> Geometry.area_loop<beginfold id='2'>(</beginfold id='2'><endfold id='2'>)</endfold id='2'> <endfold id='4'>end</endfold id='4'><endfold id='2'>)</endfold id='2'> #=> #PID<0.40.0>
# Alternatively
pid = spawn<beginfold id='2'>(</beginfold id='2'>Geometry, :area_loop, <beginfold id='3'>[</beginfold id='3'><endfold id='3'>]</endfold id='3'><endfold id='2'>)</endfold id='2'>

# Send a message to `pid` that will match a pattern in the receive statement
send pid, <beginfold id='1'>{</beginfold id='1'>:rectangle, 2, 3<endfold id='1'>}</endfold id='1'>
#=> Area = 6
#   {:rectangle,2,3}

send pid, <beginfold id='1'>{</beginfold id='1'>:circle, 2<endfold id='1'>}</endfold id='1'>
#=> Area = 12.56000000000000049738
#   {:circle,2}

# The shell is also a process, you can use `self` to get the current pid
self<beginfold id='2'>(</beginfold id='2'><endfold id='2'>)</endfold id='2'> #=> #PID<0.27.0>

# Code not found in the original, but needed to test the full range of the syntax

def function, do: <beginfold id='1'>{</beginfold id='1'>:ok, result<endfold id='1'>}</endfold id='1'>

<beginfold id='3'>[</beginfold id='3'>
  :a,
  :b,
  :c
<endfold id='3'>]</endfold id='3'>

%<beginfold id='1'>{</beginfold id='1'>
  a: "a",
  b: "b",
  c: "c"
<endfold id='1'>}</endfold id='1'>

%A<beginfold id='1'>{</beginfold id='1'>
  a: "a",
  b: "b",
  c: "c"
<endfold id='1'>}</endfold id='1'>
