Elixir (programming language)

Elixir

Paradigm	multi-paradigm: functional, concurrent, distributed, process-oriented
First appeared	2011 (2011)
Stable release	1.6.6 / 19 June 2018 (2018-06-19)
Typing discipline	dynamic, strong
Platform	Erlang
License	Apache License 2.0
Filename extensions	.ex, .exs
Website	elixir-lang.org
Influenced by
Erlang, Ruby, Clojure
Influenced
LFE

Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang virtual machine (BEAM). Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides a productive tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.

Elixir is used by companies such as E-MetroTel, Pinterest and Moz. Elixir is also used for web development, by companies such as Bleacher Report, Discord, and Inverse, and for building embedded systems. The community organizes yearly events in United States, Europe and Japan as well as minor local events and conferences.

History

José Valim is the creator of the Elixir programming language, an R&D project of Plataformatec. His goals were to enable higher extensibility and productivity in the Erlang VM while keeping compatibility with Erlang's ecosystem.

Features

• A language that compiles to bytecode for the Erlang Virtual Machine (BEAM)
• Everything is an expression
• Erlang functions can be called from Elixir without run time impact, due to compilation to Erlang bytecode, and vice versa
• Meta programming allowing direct manipulation of AST
• Polymorphism via a mechanism called protocols. Like in Clojure, protocols provide a dynamic dispatch mechanism. However, this is not to be confused with multiple dispatch as Elixir protocols dispatch on a single type.
• Support for documentation via Python-like docstrings in the Markdown formatting language
• Shared nothing concurrent programming via message passing (Actor model)
• Emphasis on recursion and higher-order functions instead of side-effect-based looping
• Lightweight concurrency utilizing Erlang's mechanisms
• Railway oriented programming via the with construct
• Built-in tooling for managing dependencies, code compilation, running tests, formatting code, remote debugging and more
• Lazy and async collections with streams
• Pattern matching to promote assertive code
• Unicode support and UTF-8 strings

Examples

The following examples can be run in an iex shell or saved in a file and run from the command line by typing elixir <filename>.

Classic Hello world example:

iex> IO.puts "Hello World!"
Hello World!

Comprehensions

iex> for n <- [1,2,3,4,5], rem(n, 2) == 1, do: n*n
[1, 9, 25]

Pattern Matching (destructuring)

iex> [1, a] = [1, 2]
iex> a
2

iex> {:ok, [hello: a]} = {:ok, [hello: "world"]}
iex> a
"world"

Pattern Matching (multiple clauses)

iex> case File.read("path/to/file") do
iex>   {:ok, contents} -> IO.puts("found file: #{contents}")
iex>   {:error, reason} -> IO.puts("missing file: #{reason}")
iex> end

Pipe Operator

iex> "1" |> String.to_integer |> Kernel.*(2)
2

Modules

defmodule Fun do
  def fib(0), do: 0
  def fib(1), do: 1
  def fib(n), do: fib(n-2) + fib(n-1)  
end

Sequentially spawning a thousand processes

for num <- 1..1000, do: spawn fn -> IO.puts "#{num * 2}" end

Asynchronously performing a task

task = Task.async fn -> perform_complex_action() end
other_time_consuming_action()
Task.await task

Noteworthy Elixir projects

• Absinthe is a GraphQL implementation for Elixir
• Ecto is a database wrapper and language integrated query for Elixir
• Mix is a build automation tool for Elixir projects
• Nerves is framework and platform for embedded software
• Phoenix is a web framework built on Elixir
• Plug is a specification and conveniences for composable modules between web applications

See also

• Concurrent computing
• Distributed computing
• Erlang (programming language)

External links

• Elixir language website
• Code on GitHub
• Elixir - A modern approach to programming for the Erlang VM (video presentation)
• Dave Thomas: "Programming Elixir ≥ 1.6 Functional |> Concurrent |> Pragmatic |> Fun" (book)
• Simon St. Laurent, J. David Eisenberg: "Introducing Elixir" (book)
• Chris McCord: "Metaprogramming Elixir " (book)