Chicago Elixir - Elixir Intro

Functional
Concurrent
Immutable

Kind of.
It’s on the Erlang VM.

Metaprogramming
Polymorphism
Tooling

1         #
1.0       #
:atom     #
{1, 2, 3} #
[1, 2, 3] #

integer"
float"
atom / symbol"
tuple"
list

[name: "Drew", age: 31] # keyword"
[{:name, "Drew"}, {:age, 31}] # keyword

HashDict.new(name: "Drew", age: 31) # HashDict

defmodule Greeter do"
  def greet(thing) do"
    IO.puts "Hello, #{thing}!""
  end"
end"
!

Greeter.greet("World")

subject = "World""
!

greeter = fn(greeting) ->"
IO.puts("#{greeting}, #{subject}!")"
end"
!

greeter.("Hello")

defrecord Person,"
name: nil,"
age: nil"
!

drew = Person.new(name: "Drew", age: 31)"
!

IO.puts(drew.name)"
IO.puts(drew.age)

defprotocol Checker do"
  @fallback_to_any true"
  def person?(data)"
end"
!

defimpl Checker, for: Person do"
  def person?(_) do"
    true"
  end"
end"
!

defimpl Checker, for: Any do"
  def person?(_) do"
    false"
  end"
end"
!

Checker.person?(Person.new)"
Checker.person?(HashDict.new)

list = [1, 2, 3]"
keyword = [a: 1, b: 2, c: 3]"
!

Enum.map list, fn(item) ->"
item * 2"
end"
!

Enum.map keyword, fn({key, val}) ->"
"#{key} -> #{val}""
end

list = [1, 2, 3]"
!

case list do"
  [head|_] ->"
    IO.puts(head)"
  [] ->"
    IO.puts("empty!")"
end

defmodule MyList do"
  def sum(list) do"
    sum(list, 0)"
  end"
!

  defp sum([head|rest], acc) do"
    sum(rest, acc + head)"
  end"
!

  defp sum([], acc) do"
    acc"
  end"
end"
!

MyList.sum([1, 2, 3])

Enum.reduce [1, 2, 3], fn(item, acc) ->"
acc + item"
end

defmodule Foo.Mixfile do"
  use Mix.Project"
!
  def project do"
    [ app: :foo,"
      version: "0.0.1","
      elixir: "~> 0.12.2","
      deps: deps ]"
  end"
!
  # Configuration for the OTP application"
  def application do"
    [mod: { Foo, [] }]"
  end"
!
  # Returns the list of dependencies in the format:"
  # { :foobar, git: "https://github.com/elixir-lang/foobar.git",
tag: "0.1" }"
  #"
  # To specify particular versions, regardless of the tag, do:"
  # { :barbat, "~> 0.1", github: "elixir-lang/barbat" }"
  defp deps do"
    []"
  end"
end

defmodule MyListTest do"
  use ExUnit.Case"
!

  test "it sums" do"
    assert MyList.sum([1, 2, 3]) == 6"
  end"
end

Chicago Elixir - Elixir Intro

More Related Content

What's hot (10)

Similar to Chicago Elixir - Elixir Intro (20)

Recently uploaded (20)

Chicago Elixir - Elixir Intro