Overview

Installation

• OSX
• Windows
• Linux

OSX

Windows

Linux

Use your package manager

Interactive

• Starting
• Breaking
• Exiting

Starting Interactive

Breaking the current command

Types

• Numeric
• Constant
• Boolean
• String
• Regular Expression
• Anonymous Function
• Collection

Numeric Types

Constant Types

Boolean Types

Strings

Regular Expressions

'`spec` is a task for `rake`'.gsub(
  /`(.*?)`/,
  '<code>\1</code>'
) # "<code>test</code> is a task for <code>rake</code>"
                                  

Regex.replace(
  ~r/`(.*?)`/,
  "`test` is a task for `mix`",
  "<code>\\1</code>"
) # <code>test</code> is a task for <code>mix</code>"
                                    

Anonymous Functions

Collections

Control Flow

• Boolean
• Rescue
• Catch

Boolean Control Flow

if false
  'This will never be seen'
else
  'This will'
end
                                    

if false do
  "This will never be seen"
else
  "This will"
end
                                    

unless true
  'This will never be seen'
else
  'This will'
end
                                    

unless true do
  "This will never be seen"
else
  "This will"
end
                                    

if one
  'one is true'
elsif two
  'two is true'
else
  'neither one nor two is true'
end
                                    

cond do
  one -> "one is true"
  two -> "two is true"
  true -> "neight one nor two is true"
end
                                    

Rescuing Exceptions

begin
  raise 'some error'
rescue RuntimeError => runtime_error
  puts runtime_error
rescue ArgumentError
  puts 'argument error occurred'
rescue => exception
  puts exception
rescue
  puts 'some exception'
else
  puts 'no exception'
ensure
  puts 'always runs'
end
                                  

try do
  raise "some error"
rescue
  x in [RuntimeError] ->
    IO.puts x.message
  ArgumentError ->
    IO.puts "argument error occurred"
  error ->
    IO.puts error
  _ ->
    IO.puts "some error"
else
  IO.puts "no error"
after
  puts "always run"
end
                                    

Catching Throws And Exits

answer = nil
catch (:done) do
  answer = 42
  throw :done
end
                                    

try do
  name = "Alice"
  throw("Hello", name)
  exit "I am exiting"
catch
  {greeting, name} ->
    IO.puts "#{greeting} to you, #{name}"
  :exit, _ -> "not really"
after
  IO.puts "Nothing thrown"
end
                                    

Pattern Matching

• Assignment to Match
• Destructuring to Match
• ArgumentError to Match
• Function Clauses
• If Else to Case Statements

Ruby Assignment to Elixir Matching

Destructuring to Match

ArgumentError to Match

a, b = [nil, 2]
unless a == 1
  raise ArgumentError,
        "a should be 1"
end
                                    

{1, b} = {0, 2}
                                    

opening, closing = [:td, :th]
unless opening == closing
  raise ArgumentError,
        "opening and closing tag don't match"
end
                                    

{tag, tag} = {:td, :th}
                                    

Function Clauses

def cat_greet(who)
  case who
  when :owner
    'Purr!'
  when :dog
    'Hiss!'
  else
    '*ignore*'
end
cat_greet(:owner) # "Purr!"
cat_greet(:dog) # "Hiss!"
cat_greet(:sitter) # "*ignore*"
                                    

cat_greet = fn
  :owner -> "Purr!"
  :dog -> "Hiss!"
  - -> "*ignore*"
end

cat_greet.(:owner) # "Purr!"
cat_greet.(:dog) # "Hiss!"
cat_greet.(:sitter) # "*ignore*"
                                    

If-else to case

fizz = n % 3 == 0
buzz = n % 5 == 0

if fizz && buzz
  'FizzBuzz'
elsif fizz
  'Fizz'
elsif buzz
  'Buzz'
else
  n
end
                                

case {rem(n, 3), rem(n, 5), n} do
  {0, 0, _} -> "FizzBuzz"
  {0, _, _} -> "Fizz"
  {_, 0, _) -> "Buzz"
  {_, _, n} -> n
end
                                

Project

• Tools
• New
• File Layout
• Packaging
• Dependency Source
• Dependency Environment
• Dependency Special Features

Tools

File Layout

Packaging

# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'example/version'

Gem::Specification.new do |spec|
  spec.name          = "example"
  spec.version       = Example::VERSION
  spec.authors       = ["Luke Imhoff"]
  spec.email         = ["luke_imhoff@rapid7.com"]

  spec.summary       = %q{TODO: Write a short summary, because Rubygems requires one.}
  spec.description   = %q{TODO: Write a longer description or delete this line.}
  spec.homepage      = "TODO: Put your gem's website or public repo URL here."
  spec.license       = "MIT"

  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
  spec.bindir        = "exe"
  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
  spec.require_paths = ["lib"]

  spec.add_development_dependency "bundler", "~> 1.10"
  spec.add_development_dependency "rake", "~> 10.0"
  spec.add_development_dependency "rspec"
end
                                    

defmodule Example.Mixfile do
  use Mix.Project

  def project do
    [app: :example,
     version: "0.0.1",
     elixir: "~> 1.0",
     deps: deps]
  end

  def application do
    [applications: [:logger]]
  end

  defp deps do
    []
  end
end
                                    

Dependency - Source

*All mix dependencies are added to the [] in Example.MixFile.deps/0

Dependency - Environment

*All mix dependencies are added to the [] in Example.MixFile.deps/0

Dependency - Advanced Features

Code

• Module
• Writing Documentation
• Reading Documentation
• Function Overloading
• Struct
• Protocol
• Recursion

Module

module Math
  def self.sum(a, b)
    a + b
  end

  def self.square(x) do
    x * x
  end
end

Math.sum(1, 2) # 3
Math.square 3 # 9
                                    

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

  def square(x) do
    x * x
  end
end

Math.sum(1, 2) # 3
Math.square 3 # 9
                                    

Writing Documentation

# Simple math functions
module Math
  # Sums two numbers.
  #
  # @param a [Number]
  # @param b [Number]
  # @return [Number] Sum of `a` and `b`
  def self.sum(a, b)
    a + b
  end

  # Multiplies `x` by itself.
  #
  # @param x [Number]
  # @return [Number]
  def self.square(x) do
    x * x
  end
end
                                    

defmodule Math do
  @moduledoc "Simple math functions"

  @doc "Sums two numbers."
  @spec sum(number, number) :: number
  def sum(a, b) do
    a + b
  end

  @doc "Multiplies `x` by itself."
  @spec square(number) :: number
  def square(x) do
    x * x
  end
end
                                    

Reading Documentation

Function Overloading

class Rectangle
  attr_reader :height, :width

  def initialize(width, height)
    @width = width
    @height = height
  end

  def area
    width * height
  end
end

Rectangle.new(2, 3).area # 6
                                    

class Circle
  attr_reader :radius

  def initialize(radius)
    @radius = radius
  end

  def area
    Math::PI * radius * radius
  end
end

Circle.new(3).area # 28.274333882308138
                                    

defmodule Geometry do
  def area({:rectangle, width, height}) do
    width * height
  end

  def area({:circle, radius}) when is_number(radius) do
    :math.pi * radius * radius
  end
end

Geometry.area({:rectangle, 2, 3}) # 6
Geometry.area({:circle, 3}) # 28.274333882308138
                                    

Struct

defmodule Rectangle do
  defstruct [:height, :width]

  def area(%__MODULE__{height: height, width: width}) do
    height * width
  end
end

defmodule Circle do
  defstruct [:radius]

  def area(%__MODULE__{radius: radius}) do
    :math.pi * radius * radius
  end
end

rectangle = %Rectangle{height: 3, width: 2}
Rectangle.area(rectangle) # 6
circle = %Circle{radius: 3}
Circle.area(circle) # 28.274333882308138
Circle.area(rectangle) # ** (FunctionClauseError) no function clause matching in Circle.area/1
                        

Protocol

Protocol	Implementation
	Inside	Outside

Usage

rectangle = %Rectangle{height: 3, width: 2}
circle = %Circle{radius: 3}
Shape.area(rectangle) # 6
Shape.area(circle) # 28.274333882308138
                            

Recursion

def sum_array(array, acc)
  if array.empty?
    acc
  else
    head, *tail = array
    sum_array(tail, acc + head)
  end
end

sum_array((0..9000).to_a, 0) # SystemStackError: stack level too deep
                                    

defmodule Recursion do
  def sum_list([head | tail], acc) do
    sum_list(tail, acc + head)
  end

  def sum_list([], acc) do
    acc
  end
end

0..9000 |> Enum.to_list |> Recursion.sum_list(0) # 40504500
                                    

Testing

• Frameworks
• Helper
• File
• Output
• Coverage
• Documentation Examples

Frameworks

Test File

RSpec.describe Example do
  it 'does not break addition' do
    expect(
      1 + 1
    ).to eq(3)
  end

  it 'does not break subtraction' do
    expect(
      1 - 1
    ).to eq(-1)
  end
end
                                    

defmodule ExampleTest do
  use ExUnit.Case,
      async: true

  test "addition" do
    assert 1 + 1 ==
           3
  end

  test "subtraction" do
    assert 1 - 1 ==
           -1
  end
end
                                    

Test Output

Ruby	Elixir
rake spec	mix test

Test Coverage

mix test --cover
open coverage/*.html
                                    

# Gemfile
gem 'simplecov', group: :test, require: false

# spec/spec_helper.rb
require 'simplecov'
SimpleCov.start
                                    

rake spec
open coverage/index.html
                                    

# mix.exs
  def project do
    [ #...
      test_coverage: [tool: ExCoveralls]
    ]
  end

  def deps do
    [{:excoveralls, only: :test}]
  end

                                    

mix test
mix coveralls.detail
                                     

# Gemfile
gem 'coveralls', group: :test, require: false

# spec/spec_helper.rb
require 'coveralls'
Coveralls.wear!
                                    

rake spec
                                    

# mix.exs
  def project do
    [ #...
      test_coverage: [tool: ExCoveralls]
    ]
  end

  def deps do
    [{:excoveralls, only: :test}]
  end
                                    

mix coveralls.travis
                                    

Testing Documentation Examples

Code	Commands
# lib/example.rb defmodule Example @doc """ Calculates line number ## Examples iex> Example.line(1, 2) 3 """ def line(start, offset) do # correct for lines being 1-index to user start + offset + 1 end end # test/example_test.ex defmodule ExampleTest do use ExUnit.Case, async: true doctest Example end	mix test

Metaprogramming

• Macros
• Keywords
• Blocks
• AST Capture
• Data to Code
• Operators

Macros

• Run at compile
• Any valid Elixir code
• Captures and transforms AST

Keywords

Blocks

require MyModule
MyModule.my_def foo do
  IO.puts "It works!"
rescue
  IO.puts "Rescued!"
catch
  IO.puts "Caught!"
else
  IO.puts "Otherwise!"
after
  IO.puts "Afterwards!
end
                                    

require MyModule
MyModule.my_def foo, do: IO.puts "It works",
                     rescue: IO.puts "Rescued!",
                     catch: IO.puts "Caught!",
                     else: IO.puts "Otherwise!",
                     after: IO.puts "Afterwards!
                                    

AST Capture

defmodule ExampleTest do
  use ExUnit.Case

  test "the truth" do
    assert 1 + 1 != 2
  end
end
                        

Compile Data into Code

defmodule MimeTypes do
  HTTPotion.start
  HTTPotion.Response[body: body] = HTTPotion.get(
    "http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types"
  )

  Enum.each String.split(body, %r/\n/), fn (line) ->
    unless line == "" or line =~ %r/^#/ do
      [ mimetype | _exts ] = String.split(line)


      def is_valid?(unquote(mimetype)), do: true
    end
  end

  def is_valid?(_mimetype), do: false
end

MimeTypes.is_valid?("application/vnd.exn") #=> false
MimeTypes.is_valid?("application/json")    #=> true
                        

Operators

# deeply nested function calls
def main(argv) do
  output(process(parse_args(argv)))
end
                        

# single-use variables
def main(argv) do
  parsed_args = parse_args(argv)
  processed = process(parsed_args)
  output(processed)
end
                        

# Pipes
def main(argv) do
  argv
  |> parse_args
  |> process
  |> output
end
                        

defmacro left |> right do
  [{h, _}|t] = Macro.unpipe({:|>, [], [left, right]})
  :lists.foldl fn {x, pos}, acc -> Macro.pipe(acc, x, pos) end, h, t
end
                        

Concurrency

• Message Passing
• Memory
• Time

Message Passing

iex> pid = spawn_link fn ->
...>   receive do
...>     {:ping, client} -> send client, :pong
...>   end
...> end
#PID<9014.59.0>
iex> send pid, {:ping, self}
{:ping, #PID<0.73.0>}
iex> flush
:pong
:ok
                        

Process Memory

f = fn -> receive do
  after
    :infinity -> :ok
  end
end
{_, bytes} = Process.info(spawn(f), :memory)
bytes # 2680
                        

Process Time (1)

defmodule ElixirLunchAndLearn.Chain do
  def run(n) do
    {microseconds, result} = :timer.tc(__MODULE__, :create_processes, [n])
    IO.puts "#{result} (Calculated in #{microseconds} microseconds)"
  end
end
                        

Process Time (2)

defmodule ElixirLunchAndLearn.Chain do
  def create_processes(n) do
    last = Enum.reduce 1..n,
                       self,
                       fn(_, send_to) ->
                         spawn(__MODULE__, :counter, [send_to])
                       end

    # start the count by sending
    send last, 0

    # and wait for the result to come back to us
    receive do
      final_answer when is_integer(final_answer) ->
        "Result is #{inspect final_answer}"
    end
  end
end
                       

Process Time (3)

defmodule ElixirLunchAndLearn.Chain do
  def counter(next_pid) do
    receive do
      n ->
        send next_pid, n + 1
    end
  end
end
                        

Process Time (4)

> elixir --erl "+P 1000000" -r lib/elixir_lunch_and_learn/chain.ex -e "ElixirLunchAndLearn.Chain.run(1_000_000)"
Result is 1000000 (Calculated in 11658944 microseconds)
                        

Resources

• Intros
• Help
• Videos
• Books
• Websites
• Editors

Intros

Help

Videos

Books

Websites

Editors