The code of the short Elixir demo presented at the first Elixir Meetup in Düsseldorf

demo.exs

#### basic data types

x = 1
y = 2
x + y

string = "I am a string and a binary!"
binary = <<69, 76, 73, 88, 73, 82, 1>>

charlist = 'I am NOT a string'
is_binary(charlist)
is_list(charlist)

list = ["I am", :a_list] ++ ["that was concatenated"]
list = ["Hello, " | list]
[head | tail] = list
head
tail

Enum.map([1, 2, 3], fn i -> i + 1 end)
[1, 2, 3] |> Enum.map(fn i -> i + 1 end) |> Enum.take(2)

odd? = &(rem(&1, 2) != 0)
1..500_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.take(10)
1..500_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.take(10)

{"this is", "a tuple"}

[keyword: "list"]
[{:keyword, "list"}]

map = %{one: 1, two: 2}
%{map | four: 3}

mixed_map = %{"one" => 1, :two => <<69, 76, 73, 88, 73, 82>>}
%{"one" => one} = mixed_map
one

defmodule User do
  defstruct [name: nil, age: 18]
end
%User{}
%User{name: "Mario", age: 28}
%User{name: "Mario", height: 180}
struct(User, %{name: "Mario"})


#### comprehensions

for n <- 1..4, do: n * n

for i <- 1..10,
    j <- 10..20,
    n = i * j,
    n <= 50,
    rem(n, 2) == 0,
    do: n


#### defining functions

defmodule Demo do
  def greet(nicely) do
    if nicely do
      IO.puts "Very nice to meet you!"
    else
      IO.puts "Hi"
    end
  end
end

Demo.greet(true)
Demo.greet(false)
Demo.greet(nil)

defmodule Demo do
  def greet(true), do: IO.puts "Very nice to meet you!"
  def greet(false), do: IO.puts "Hi"
end

Demo.greet(true)
Demo.greet(false)
Demo.greet(1)

defmodule Demo do
  def greet(true), do: IO.puts "Very nice to meet you!"
  def greet(false), do: IO.puts "Hi"
  def greet(_), do: IO.puts "WTF are you doing!?"
end

Demo.greet(true)
Demo.greet(false)
Demo.greet(1)


#### macros

quote do
  1 + 1
end

x = 2
quote do
  x + 1
end

quote do
  unquote(x) + 1
end

defmodule Tracer do
  defmacro trace(expression_ast) do
    string_representation = Macro.to_string(expression_ast)

    quote do
      result = unquote(expression_ast)
      IO.puts "Result of #{unquote(string_representation)}: #{inspect result}"
      result
    end
  end
end
require Tracer
Tracer.trace(1 + 2)


#### processes

spawn fn -> 1 + 2 end
parent = self
spawn fn -> send parent, 1 + 2 end
flush

spawn fn -> raise "oops" end
spawn_link fn -> raise "oops" end

task = Task.async(fn -> 1 + 2 end)
IO.inspect task
Task.await(task)

{:ok, agent} = Agent.start_link(fn -> %{} end)
Agent.get(agent, fn map -> map[:test] end)
Agent.update(agent, fn map -> Map.put(map, :test, 1) end)
Agent.get(agent, fn map -> map[:test] end)

defmodule EchoServer do
  use GenServer

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, %{}, opts)
  end

  def echo(server, text) do
    GenServer.call(server, {:echo, text})
  end

  def handle_call({:echo, text}, from, state) do
    IO.puts text

    {:reply, :ok, state}
  end
end
{:ok, server} = EchoServer.start_link
EchoServer.echo(server, "HELLO")

{:ok, server} = EchoServer.start_link(name: EchoServer)
EchoServer.echo(EchoServer, "HELLO AGAIN")
EchoServer.echo(EchoServer, fn -> :moep end)

defmodule EchoSupervisor do
  use Supervisor

  def start_link do
    Supervisor.start_link(__MODULE__, [])
  end

  def init([]) do
    children = [
      worker(EchoServer, [[name: EchoServer]])
    ]

    supervise(children, strategy: :one_for_one)
  end
end
{:ok, supervisor} = EchoSupervisor.start_link
EchoServer.echo(EchoServer, "HELLO")
EchoServer.echo(EchoServer, fn -> :moep end)


#### observer

:"Elixir.Enum".drop([1, 2, 3], 2)
:observer.start