Elixir (programming language) – Wikipedia

Programming language running on the Erlang virtual machine

Elixir is a functional, concurrent, high-level general-purpose programming language that runs on the BEAM virtual machine, which is also used to implement the Erlang programming language.^[3] Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.^[4]

Elixir is used by companies such as Ramp,^[5]PagerDuty,^[6]Discord,^[7]Brex,^[8] E-MetroTel,^[9]Pinterest,^[10] Moz,^[11]Bleacher Report,^[12]The Outline,^[13]Inverse,^[14] Divvy,^[15]FarmBot^[16] and for building embedded systems.^[17][18] The community organizes yearly events in the United States,^[19] Europe,^[20] and Japan,^[21] as well as minor local events and conferences.^[22][23]

History[edit]

José Valim is the creator of the Elixir programming language, a research and development project created at Plataformatec. His goals were to enable higher extensibility and productivity in the Erlang VM while maintaining compatibility with Erlang’s ecosystem.^[24][25]

Elixir was aimed at large-scale sites and apps. Elixir uses features of Ruby, Erlang, and Clojure to develop a “high-concurrency” and “low-latency” language. Elixir was designed to handle large data volumes. Elixir is used in the telecommunication, eCommerce, and finance industries.^[26]

On July 12, 2018, Honeypot released a mini-documentary on Elixir.^[27]

Versioning[edit]

Elixir mostly^[28] follows semantic versioning and has only 1 major version with no plans for a second. Each of the minor versions supports a specific range of Erlang/OTP versions.^[29] The current stable release version is 1.14.3^[1] .

Features[edit]

• Compiles to bytecode for the BEAM virtual machine of Erlang.^[30] Full interoperability with Erlang code, without runtime impact.
• Scalability and fault-tolerance, thanks to Erlang’s lightweight concurrency mechanisms^[30]
• Built-in tooling for managing dependencies, code compilation, running tests, formatting code, remote debugging and more.
• An interactive REPL inside running programs, including Phoenix web servers, with code reloading and access to internal state
• Everything is an expression^[30]
• Pattern matching^[30] to promote assertive code^[31]
• Type hints for static analysis tools
• Immutable data, with an emphasis, like other functional languages, on recursion and higher-order functions instead of side-effect-based looping
• Shared nothing concurrent programming via message passing (actor model)^[32]
• Lazy and async collections with streams
• Railway oriented programming via the with construct^[33]
• Hygienic metaprogramming by direct access to the abstract syntax tree (AST).^[30] Libraries often implement small domain-specific languages, such as for databases or testing.
• Code execution at compile time. The Elixir compiler also runs on the BEAM, so modules that are being compiled can immediately run code which has already been compiled.
• Polymorphism via a mechanism called protocols. Dynamic dispatch, as in Clojure, however, without multiple dispatch because Elixir protocols dispatch on a single type.
• Support for documentation via Python-like docstrings in the Markdown formatting language^[30]
• Unicode support and UTF-8 strings

Examples[edit]

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

Classic Hello world example:

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

Pipe operator:

iex> "Elixir" |> String.graphemes() |> Enum.frequencies()
%{"E" => 1, "i" => 2, "l" => 1, "r" => 1, "x" => 1}

iex> %{values: 1..5} |> Map.get(:values) |> Enum.map(& &1 * 2)
[2, 4, 6, 8, 10]

iex> |> Enum.sum()
30

Pattern matching (a.k.a. destructuring):

iex> %{left: x} = %{left: 5, right: 8}
iex> x
5

iex> {:ok, [_ | rest]} = {:ok, [1, 2, 3]}
iex> rest
[2, 3]

Pattern matching with 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

List comprehension:

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

Asynchronously reading files with streams:

1..5
|> Task.async_stream(&File.read!("#{&1}.txt"))
|> Stream.filter(fn {:ok, contents} -> String.trim(contents) != "" end)
|> Enum.join("n")

Multiple function bodies with guards:

def fib(n) when n in [0, 1], do: n
def fib(n), do: fib(n-2) + fib(n-1)

Relational databases with the Ecto library:

schema "weather" do
  field :city     # Defaults to type :string
  field :temp_lo, :integer
  field :temp_hi, :integer
  field :prcp,    :float, default: 0.0
end

Weather |> where(city: "Kraków") |> order_by(:temp_lo) |> limit(10) |> Repo.all

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[edit]

• Mix is a build automation tool that provides tasks for creating, compiling, and testing Elixir projects, managing its dependencies, and more.^[34]
• Phoenix is a web development framework written in Elixir which implements the server-side Model View Controller (MVC) pattern.^[35]

See also[edit]

References[edit]

External links[edit]