Elixir (langage de programmation)

Elixir est un langage de programmation fonctionnel , concurrent et généraliste de haut niveau qui s'exécute sur la machine virtuelle BEAM , également utilisée pour implémenter le langage Erlang . Elixir s'appuie sur Erlang et partage les mêmes abstractions pour la création d'applications distribuées et tolérantes aux pannes . Elixir fournit également des outils et une conception extensible . Cette dernière est prise en charge par la métaprogrammation à la compilation avec des macros et le polymorphisme via des protocoles.

La communauté organise des événements annuels aux États-Unis, en Europe, et au Japon, ainsi que des événements et conférences locaux de moindre envergure.

Histoire

José Valim a créé le langage de programmation Elixir dans le cadre d'un projet de recherche et développement chez Plataformatec. Son objectif était d'améliorer l'extensibilité et la productivité de la machine virtuelle Erlang tout en maintenant la compatibilité avec l'écosystème Erlang.

Elixir est destiné aux sites et applications de grande envergure. Il utilise des fonctionnalités de Ruby , Erlang et Clojure pour développer un langage à haute concurrence et faible latence. Il a été conçu pour gérer de grands volumes de données. Elixir est également utilisé dans les télécommunications, le commerce électronique et la finance.

En 2021, l'initiative Numerical Elixir a été annoncée dans le but d'intégrer l'apprentissage automatique, les réseaux neuronaux, la compilation GPU, le traitement des données et les notebooks de calcul à l'écosystème Elixir.

Caractéristiques

Compile en bytecode pour la machine virtuelle BEAM d' Erlang . Interopérabilité complète avec le code Erlang, sans impact sur l'exécution .
Évolutivité et tolérance aux pannes, grâce aux mécanismes de concurrence légers d'Erlang
Outils intégrés pour la gestion des dépendances, la compilation du code, l'exécution des tests, le formatage du code, le débogage à distance et bien plus encore.
Un REPL interactif intégré aux programmes en cours d'exécution, y compris les serveurs web Phoenix , avec rechargement du code et accès à l'état interne
Tout est une expression
Correspondance de modèles pour promouvoir un code assertif
Suggestions de type pour les outils d'analyse statique
Données immuables, avec une emphase, comme dans d'autres langages fonctionnels , sur la récursivité et les fonctions d'ordre supérieur plutôt que sur les boucles à effets de bord.
Programmation concurrente sans partage via passage de messages ( modèle d'acteurs )
Collections paresseuses et asynchrones avec flux
Programmation orientée vers le secteur ferroviaire via la withconstruction
Métaprogrammation hygiénique par accès direct à l' arbre de syntaxe abstraite (AST). Les bibliothèques implémentent souvent de petits langages spécifiques au domaine , comme pour les bases de données ou les tests.
Exécution du code à la compilation. Le compilateur Elixir s'exécute également sur la BEAM ; les modules en cours de compilation peuvent donc exécuter immédiatement le code déjà compilé.
Le polymorphisme s'effectue via un mécanisme appelé protocoles. La répartition dynamique , comme en Clojure , n'est cependant pas multiple car les protocoles Elixir répartissent les appels sur un seul type.
Prise en charge de la documentation via des chaînes de documentation de type Python dans le langage de formatage Markdown
Prise en charge d'Unicode et des chaînes UTF-8

Exemples

Les exemples suivants peuvent être exécutés dans un iexshell ou enregistrés dans un fichier et exécutés à partir de la ligne de commande en tapant .elixir <filename>

Exemple classique de « Hello world » :

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

Opérateur de canalisation :

iex> "Elixir" |> String . graphèmes () |> Enum . frequencies () %{"E" => 1, "i" => 2, "l" => 1, "r" => 1, "x" => 1}iex> %{ valeurs : 1 .. 5 } |> Map . get ( :values ) |> Enum . map ( & &1 * 2 ) [2, 4, 6, 8, 10]iex> %{ values : 1 .. 5 } |> Map . get ( :values ) |> Enum . map ( & &1 * 2 ) |> Enum . sum () 30

Appariement de motifs (ou déstructuration) :

iex> %{ gauche : x } = %{ gauche : 5 , droite : 8 } iex> x 5iex> { :ok , [ _ | reste ]} = { :ok , [ 1 , 2 , 3 ]} iex> reste [2, 3]

Correspondance de modèles avec plusieurs clauses :

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

Compréhension de liste :

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

Lecture asynchrone de fichiers avec des flux :

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

Corps multifonctionnels avec gardes :

def fib ( n ) quand n dans [ 0 , 1 ], faire : n def fib ( n ), faire : fib ( n - 2 ) + fib ( n - 1 )

Bases de données relationnelles avec la bibliothèque Ecto :

schéma "weather" do champ :city # Par défaut, type :string champ :temp_lo , :integer champ :temp_hi , :integer champ :prcp , :float , default : 0.0 endMétéo |> où ( ville : "Cracovie" ) |> trier_par ( :temp_lo ) |> limiter ( 10 ) |> Repo . tout

Génération séquentielle de mille processus :

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

Exécution asynchrone d'une tâche :

tâche = Tâche.async fn- > perform_complex_action ( ) end autre_action_consommatrice_de_temps ( ) Tâche.await tâche