Elixir (programming language)

Elixir is a Brazilian 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]

The community organizes yearly events in the United States,^[5] Europe,^[6] and Japan,^[7] as well as minor local events and conferences.^{[8] [9]}

José Valim created the Elixir programming language as a research and development project at Plataformatec. His goals were to enable higher extensibility and productivity in the Erlang VM while maintaining compatibility with Erlang's ecosystem.^{[10] [11]}

Elixir is aimed at large-scale sites and apps. It uses features of Ruby, Erlang, and Clojure to develop a high-concurrency and low-latency language. It was designed to handle large data volumes. Elixir is also used in telecommunications, e-commerce, and finance.^[12]

In 2021, the Numerical Elixir effort was announced with the goal of bringing machine learning, neural networks, GPU compilation, data processing, and computational notebooks to the Elixir ecosystem.^[13]

Each of the minor versions supports a specific range of Erlang/OTP versions.^[14] The current stable release version is 1.18.3^[1]  Edit this on Wikidata .

• Compiles to bytecode for the BEAM virtual machine of Erlang.^[15] Full interoperability with Erlang code, without runtime impact.
• Scalability and fault-tolerance, thanks to Erlang's lightweight concurrency mechanisms^[15]
• 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 ^[15]
• Pattern matching ^[15] to promote assertive code^[16]
• 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)^[17]
• Lazy and async collections with streams
• Railway oriented programming via the with construct^[18]
• Hygienic metaprogramming by direct access to the abstract syntax tree (AST).^[15] 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^[15]
• Unicode support and UTF-8 strings

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!

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> caseFile.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> forn<-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:

deffib(n)whennin[0,1],do:n
deffib(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:

fornum<-1..1000,do:spawnfn->IO.puts("#{num*2}")end

Asynchronously performing a task:

task=Task.asyncfn->perform_complex_action()end
other_time_consuming_action()
Task.awaittask

^{[citation needed ]}

• Concurrent computing
• Distributed computing
• Parallel computing

• Simon St. Laurent; J. Eisenberg (December 22, 2016). Introducing Elixir: Getting Started in Functional Programming 2nd Edition. O'Reilly Media. ISBN 978-1491956779.
• Sasa Juric (January 12, 2019). Elixir in Action 2nd Edition. Manning Publications. ISBN 978-1617295027.

• Concurrent programming languages
• Functional languages
• Pattern matching programming languages
• Programming languages
• Programming languages created in 2012
• Software using the Apache license

• CS1 maint: location
• Articles with short description
• Short description is different from Wikidata
• Articles lacking reliable references from June 2023
• All articles lacking reliable references
• All articles with unsourced statements
• Articles with unsourced statements from June 2023