Paradigms | multi-paradigm: functional, concurrent, distributed, process-oriented |
---|---|
Designed by | José Valim |
First appeared | 2012 |
Stable release | |
Typing discipline | dynamic, strong |
Platform | Erlang |
License | Apache License 2.0 [2] |
Filename extensions | .ex, .exs |
Website | elixir-lang |
Influenced by | |
Clojure, Erlang, Ruby | |
Influenced | |
Gleam, LFE |
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]
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.16.2 [1] .
with
construct [18] 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> x5iex> {:ok,[_|rest]}={:ok,[1,2,3]}iex> rest[2, 3]
Pattern matching with multiple clauses:
iex> caseFile.read("path/to/file")doiex> {:ok,contents}->IO.puts("found file: #{contents}")iex> {:error,reason}->IO.puts("missing file: #{reason}")iex> end
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:ndeffib(n),do:fib(n-2)+fib(n-1)
Relational databases with the Ecto library:
schema"weather"dofield:city# Defaults to type :stringfield:temp_lo,:integerfield:temp_hi,:integerfield:prcp,:float,default:0.0endWeather|>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()endother_time_consuming_action()Task.awaittask
[ citation needed ]
Erlang is a general-purpose, concurrent, functional high-level programming language, and a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or Open Telecom Platform (OTP), which consists of the Erlang runtime system, several ready-to-use components (OTP) mainly written in Erlang, and a set of design principles for Erlang programs.
Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.
This is a "genealogy" of programming languages. Languages are categorized under the ancestor language with the strongest influence. Those ancestor languages are listed in alphabetic order. Any such categorization has a large arbitrary element, since programming languages often incorporate major ideas from multiple sources.
Template metaprogramming (TMP) is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates can include compile-time constants, data structures, and complete functions. The use of templates can be thought of as compile-time polymorphism. The technique is used by a number of languages, the best-known being C++, but also Curl, D, Nim, and XL.
F# is a general-purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. It is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but can also generate JavaScript and graphics processing unit (GPU) code.
D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language drawing inspiration from other high-level programming languages, notably Java, Python, Ruby, C#, and Eiffel.
In computer programming, an entry point is the place in a program where the execution of a program begins, and where the program has access to command line arguments.
Concurrent computing is a form of computing in which several computations are executed concurrently—during overlapping time periods—instead of sequentially—with one completing before the next starts.
In computer science, ahead-of-time compilation is the act of compiling an (often) higher-level programming language into an (often) lower-level language before execution of a program, usually at build-time, to reduce the amount of work needed to be performed at run time.
Clojure is a dynamic and functional dialect of the Lisp programming language on the Java platform.
In computer programming, the async/await pattern is a syntactic feature of many programming languages that allows an asynchronous, non-blocking function to be structured in a way similar to an ordinary synchronous function. It is semantically related to the concept of a coroutine and is often implemented using similar techniques, and is primarily intended to provide opportunities for the program to execute other code while waiting for a long-running, asynchronous task to complete, usually represented by promises or similar data structures. The feature is found in C#, C++, Python, F#, Hack, Julia, Dart, Kotlin, Rust, Nim, JavaScript, Swift and Zig.
Lisp Flavored Erlang (LFE) is a functional, concurrent, garbage collected, general-purpose programming language and Lisp dialect built on Core Erlang and the Erlang virtual machine (BEAM). LFE builds on Erlang to provide a Lisp syntax for writing distributed, fault-tolerant, soft real-time, non-stop applications. LFE also extends Erlang to support metaprogramming with Lisp macros and an improved developer experience with a feature-rich read–eval–print loop (REPL). LFE is actively supported on all recent releases of Erlang; the oldest version of Erlang supported is R14.
Nim is a general-purpose, multi-paradigm, statically typed, compiled high-level systems programming language, designed and developed by a team around Andreas Rumpf. Nim is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages as intermediate representations.
Mix is a build automation tool for working with applications written in the Elixir programming language. Mix was created in 2012 by Anthony Grimes, who took inspiration from Clojure's Leiningen. Soon after, Mix was merged into the Elixir programming language itself and to this day is one of the six applications that are part of the Elixir language. Mix provides functionality for creating, compiling, and testing Elixir source code and for managing dependencies and deploying Elixir applications.
BEAM is the virtual machine at the core of the Erlang Open Telecom Platform (OTP). BEAM is part of the Erlang Run-Time System (ERTS), which compiles Erlang source code into bytecode, which is then executed on the BEAM. BEAM bytecode files have the .beam
file extension.
Phoenix is a web development framework written in the functional programming language Elixir.
Tokio is a software library for the Rust programming language. It provides a runtime and functions that enable the use of asynchronous I/O, allowing for concurrency in regards to task completion.
Gleam is a general-purpose, concurrent, functional high-level programming language that compiles to Erlang or JavaScript source code.
{{cite book}}
: CS1 maint: location (link)