Elixir

• _ will ignore a value during the match.

• Like a wildcard saying "I'll accept any value here".

  [1, _, _] = [1, 2, 3] # [1, 2, 3]
  [1, _, _] = [1, "c", "d"] # [1, "c", "d"]
  

  • [1, _, _] matches any list of length three with first element = 1.

• to force Elixir to use existing value of the variable in the pattern, prefix the variable with ^.

  a = 1
  [^a, 2, 3] = [1, 2, 3] # gives [1, 2, 3]
  [^a, 2, 3] = [4, 2, 3] # give error, a cannot be matched to anything other than 1
  

• Elixir's pattern matching works same as Erlang, except in Erlang, a variable once matched cannot be matched again.
  • Erlang's meaning of = is similar to algebraic =, when we say x = a + 2, we do not again value of a + 2 to x, instead say both x and a + 2 have same value.

• there is strict equality operator similar to JavaScript

  a === b # 1 == 1.0 is false
  a == b  # 1 == 1.0 is true
  

• Usual comparison operator included
• or, and, not
• div gives integer arithmatic
• rem is remainder operator, differs from modulo operator in that the result has same sign as functions first argument: (rem(11, 3) → 2)
• with operator is similar to Python's with except it works with pattern matching allowing alternate values in case pattern matching fails.

fn
(a, b) -> a + b
(a, b, c) -> a + b + c
end

sum = fn (a, b) -> a + b end
sum.(1, 2) # gives 3

** (CompileError) iex:1: cannot mix clauses with different arities in anonymous functions
    (iex) expanding macro: IEx.Helpers.import_file/1
    iex:10: (file)

• Use . to invoke a annonymous function
  • Don't need . to invoke named function
• When we invoke sum.(1, 2), (1, 2) is assigned to (a, b)
  • assigning is pattern matching
  • Elixir tries to match (1, 2) with (a, b)

• functions can be nested

  fn ->
    (fn ->
      "Hello from inner"
    end)
  end
  

  #Function<20.99386804/0 in :erl_eval.expr/5>
  

• They have closures - inner functions remembers their original environment.

  prefixer = fn prefix ->
               fn str ->
                 "#{prefix} #{str}"
               end
             end
  
  respectify = prefixer.("Sir")
  respectify.("Tagore")
  

  "Sir Tagore"
  

• syntactic sugar for short helper functions

  times_2 = &(&1 * 2) # same as (fn a -> 2 * a)
  times_2.(12)
  

  24
  

• Here &1, &2… so on corresponds to first argument, second argument and so on.
• If the anonymous function is used to call some other function, Elixir can optimize away the outer call.

• Exercises

  #Enum.map [1,2,3,4], fn x -> x + 2 end
  Enum.map [1,2,3,4], &(&1 + 2)
  
  #Enum.each [1,2,3,4], fn x -> IO.inspect x end
  Enum.each [1,2,3,4], &(IO.inspect &1)
  

  1
  2
  3
  4
  :ok
  

• A function is identified by its name and arity

  defmodule Times do
    def double(n) do # double/1
      n * 2
    end
  
    def doubleTrouble(n, m) do # doubleTrouble/2
      a = n * 2
      m * n * a
    end
  end
  

defmodule Fibonacci do
  def of(0), do: 0

  def of(1), do: 1

  def of(n), do: of(n - 1) + of(n - 2)
end

Fibonacci.of(15)

610

Pattern matching allows Elixir to choose a function based on the arguments passed. Clauses allow functions to be chosen based on some arbitary predicate. Clauses are predicates that are attached to function definition using one or more when clause.

defmodule Guard do
  def of(x) when is_number(x) do
    IO.puts "#{x} is a number"
  end

  def of(x) when is_list(x) do
    IO.puts "#{x} is a list"
  end

  def of(x) when is_atom(x) do
    IO.puts "#{x} is an atom"
  end
end

Guard.of(12)

12 is a number
:ok

• A good use case would be to allow application of Fibonacci.of to allow only positive numbers by adding guard:

  defmodule Fibonacci do
    # ... rest of methods
    def of(n) when n > 2 do
      of(n - 2) + of(n - 1)
    end
  end
  

• default parameters are allowed in any order.
• parameters passed are matched left to right.

• Syntax:

  defmodule Dparameters do
    def func(p1, p2 \\ 2, p3 \\ 3, p4) do
      IO.inspect [p1, p2, p3, p4]
    end
  end
  
  Dparameters.func("a", "b")
  Dparameters.func("a", "b", "c")
  Dparameters.func("a", "b", "c", "d")
  

  ["a", 2, 3, "b"]
  ["a", "b", 3, "c"]
  ["a", "b", "c", "d"]
  

defmodule Chop do
  def guess(actual, low..high) when (low <= actual and low <= high) do
    guess_helper(actual, low..high)
  end

  def guess_helper(actual, low..high) when (actual < div(low + high, 2)) do
    IO.puts "Is it #{div(low + high, 2)}"
    guess_helper(actual, low..div(low + high, 2))
  end

  def guess_helper(actual, low..high) when (actual == div(low + high, 2)) do
    div(low + high, 2)
  end

  def guess_helper(actual, low..high) when (div(low + high, 2) < actual) do
    IO.puts "Is it #{div(low + high, 2)}"
    guess_helper(actual, div(low + high, 2)..high)
  end
end

Chop.guess(273, 1..1000)

Is it 500
Is it 250
Is it 375
Is it 312
Is it 281
Is it 265
273

• Note that we have not used if statements yet.

• defp defines private function – a function that can be called only within a module
• defp is a macro
• all function with multiple heads should be either public or private but not mixed

• Syntax

  defp priFun(n), do: IO.puts("I'm a private fun")
  

• |> operator takes result of expression on left and inserts it as the first parameter of the function invocation to its right.
  • We can provide 2nd arguments if needed

• syntax

  top_10_marks = get_top(get_marks(get_students(:class9)), 10)
  # can be written as
  top_10_marks = get_students(:class9)
                   |> get_marks
                   |> get_top(10)
  

• can be nested
• call function in nested module as OuterModule.InnerModule.funName
• module nesting is an illusion – Elixir puts all modules in global namespace and prepends outer module name to inner module name with a "."

• import puts all function in module in current scope.

  import List, only: [flatten: 1, duplicate: 2]
  # optional second parameter lets you control which functions or macros are
  # imported.
  # you can use only: or except:
  

• we can make alias for modules, specially nested modules

  alias OuterModule.Innermodule.InnerModule.Parser, as: Parser
  

• each module have associated metadata. Each item is called attribute
• @name value

• attributes can be defined at top level and can be accessed at any level

  defmodule CoolModule do
    @author "Anurag Peshne"
    def author do
      @author
    end
  end
  
  CoolModule.author
  

  "Anurag Peshne"
  

  • Attributes are not variables. Use them for configuration and metadata only.
    • Can be used instead of constants.

• Internally, module names are just atoms. When you write a name starting with an uppercase letter, Elixir converts it internally into an atom. IO gets converted to Elixir.IO

  IO.puts(is_atom IO)
  IO.puts(to_string IO)
  IO.puts :"Elixir.IO" == IO
  # so IO can be written as
  :"Elixir.IO".puts("hello real module")
  

  true
  Elixir.IO
  true
  hello real module
  :ok
  

• Erlang variables starts with an uppercase letter
• and atoms are lowercase names
• To call Erlang's module, say timer, use atom :timer in Elixir

• Erlang's crypto

  :crypto.hash(:md5, "input string") |> Base.encode16()
  

  "164C375B4A5DF44A332CA34BDA6CBA9D"
  

• take a list and return list of square

  defmodule ListOps do
    def sqList([]) do
      []
    end
  
    def sqList([head | tail]) do
      [head * head | sqList(tail)]
    end
  end
  
  ListOps.sqList([1,2,3,4])
  

  [1, 4, 9, 16]
  

• Map:

  defmodule MyMap do
    def map([], _func), do: []
    def map([head | tail], func), do: [func.(head) | map(tail, func)]
  end
  
  MyMap.map([1,2,3,4], &(&1 * &1))
  

  [1, 4, 9, 16]
  

  • Note the . during application of func in body of map.

• keyword lists
• map: %{name: value}

• a map that has fixed set of fields and default values for those fields, and we can pattern match by type as well as content.

• The name of the module is name of the map type. Inside module use defstruct macro to define the struct's member.

  defmodule Subscriber do
    defstruct name: "", paid: false, over_18: true
  end
  

• we can add struct specific functions in module.

• greedy

• lazy
• Infinite stream possible

• double quote are strings
  • double quoted strings are binaries
• single quote are character list

• if <condition> do: <statments> [else: statements]
• unless <condition> do: <statments> [else: statments]

• if and unless act opposite:

  unless 1 == 2 do
    :ok
  else
    "Error"
  end
  

  :ok
  

• similar to lisp cond:

  • takes in series of condition and evaluates them:

    val = 2
    cond do
      val == 1 -> "one"
      val == 2 -> "two"
      val == 3 -> "three"
    end
    

    "two"
    

• matches value against set of patterns

  val = 3
  case val do
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
  end
  

  "Three"