Lasagnes

Les bases

Variables

Elixir est un langage à typage dynamique, ce qui signifie que le type d'une variable n'est vérifié qu'à l'exécution. Grâce à l'opérateur de correspondance =, on peut lier une valeur de n'importe quel type à un nom de variable :

# Bound an integer value of 1
count = 1
# You may re-bind variables
count = 2

# You may re-bind any type to a variable
count = false

# Strings can be created by enclosing characters within double quotes
message = "Success!"

Modules

Elixir est un langage de programmation fonctionnelle et exige que toutes les fonctions nommées soient définies dans un module. Le mot-clé defmodule sert à définir un module. Tous les modules sont accessibles à tous les autres modules à l'exécution et n'ont pas besoin d'un modificateur d'accès pour être visibles depuis les autres parties du programme. Un module est l'équivalent d'une classe dans d'autres langages de programmation.

defmodule Calculator do
  # ...
end

Fonctions nommées

Les fonctions nommées doivent être définies dans un module. Le mot-clé def sert à définir une fonction nommée publique.

Chaque fonction peut prendre zéro argument ou plus. La valeur de la dernière expression d'une fonction est toujours renvoyée implicitement.

defmodule Calculator do
  def add(x, y) do
    x + y
  end
end

Pour appeler une fonction, on précise son module et son nom, puis on passe une valeur pour chacun de ses arguments.

sum = Calculator.add(1, 2)
# => 3

Le mot-clé defp peut être utilisé à la place de def pour définir une fonction privée. Les fonctions privées ne sont utilisables qu'à l'intérieur du module qui les a définies.

Lorsqu'on appelle une fonction depuis le module où elle est définie, on peut omettre le nom du module.

Tu peux aussi écrire des fonctions courtes avec une syntaxe sur une seule ligne (remarque la virgule , et les deux-points : autour du mot-clé do).

defmodule Calculator do
  def subtract(x, y) do
    private_subtract(x, y)
  end

  defp private_subtract(x, y), do: x - y
end

difference = Calculator.subtract(7, 2)
# => 5

difference = Calculator.private_subtract(7, 2)
# => ** (UndefinedFunctionError) function Calculator.private_subtract/2 is undefined or private
#       Calculator.private_subtract(7, 2)

L'arité des fonctions

Il est courant de désigner les fonctions par leur arité. L'arité d'une fonction est le nombre d'arguments qu'elle accepte.

# add/3 because this function has three arguments, thus an arity of 3
def add(x, y, z) do
  x + y + z
end

Conventions de nommage

Les noms de modules doivent utiliser le PascalCase. Un nom de module doit commencer par une lettre majuscule A-Z et peut contenir des lettres a-zA-Z, des chiffres 0-9 et des underscores _.

Les noms de variables et de fonctions doivent utiliser le snake_case. Un nom de variable ou de fonction doit commencer par une lettre minuscule a-z ou un underscore _, peut contenir des lettres a-zA-Z, des chiffres 0-9 et des underscores _, et peut se terminer par un point d'interrogation ? ou un point d'exclamation !.

La bibliothèque standard

Elixir dispose d'une bibliothèque standard très riche et bien documentée. La documentation est disponible en ligne sur hexdocs.pm/elixir. Garde ce lien quelque part, tu t'en serviras souvent !

La plupart des types de données intégrés ont un module correspondant qui propose des fonctions pour manipuler ce type de données, par exemple le module Integer pour les entiers, le module String pour les strings, le module List pour les listes, et ainsi de suite.

Un module notable est le module Kernel. Il fournit les capacités de base sur lesquelles repose le reste de la bibliothèque standard, comme les opérateurs arithmétiques, les macros de contrôle de flux, et bien d'autres choses encore. Les fonctions du module Kernel sont importées automatiquement, tu peux donc les utiliser sans le préfixe Kernel..

Les commentaires dans le code

Les commentaires permettent de laisser des notes aux autres développeurs qui lisent le code source. En Elixir, les commentaires sur une seule ligne sont précédés d'un #.