Introduction à l'élixir Lang

Publié: 2015-02-27

Une introduction au langage de programmation Elixir (et pourquoi je l'aime)

J'ai écrit un article il y a quelques mois pour vous présenter Golang et pourquoi je l'aimais tant. Bien que je l'aime toujours, ces derniers temps, j'ai joué avec une nouvelle langue; Élixir. J'ai acheté le livre Programming Elixir et je l'ai suivi jusqu'au bout. J'aime déjà Elixir et j'espère vous montrer pourquoi dans cet article.

Alors que je travaillais pour Couchbase il y a quelques années, je me suis beaucoup intéressé à Erlang et aux systèmes distribués. Pour moi, Erlang est déroutant. Quand j'ai vu Elixir, j'ai immédiatement su que j'étais sur quelque chose de bien. Elixir est décrit comme un langage fonctionnel et concurrent qui s'exécute au-dessus de la machine virtuelle Erlang.

J'ai entendu beaucoup de fois, des gens dire qu'Elixir est "Ruby pour Erlang", etc. Cette théorie n'est pas totalement incorrecte, mais de manière réaliste, c'est principalement la syntaxe d'Elixir qui est influencée par Ruby, car elle ne partage pas bon nombre des mêmes constructions de programmation. Il est, bien sûr, similaire à Erlang, car il est construit au-dessus de la machine virtuelle Erlang et nous donne un accès direct aux primitives Erlang de manière native.

Quoi qu'il en soit, sans plus hésiter, plongeons et continuons avec un peu d'élixir.

Installation

Si vous utilisez OSX, l'installation est aussi simple que d'utiliser Homebrew :
~ brew update
~ brew install erlang
~ brew install elixir

Une fois que vous avez fait cela, vous devriez pouvoir exécuter :

~ elixir -v
> Elixir 1.0.2

Maintenant qu'Elixir est correctement installé, nous pouvons ouvrir un Elixir interactif et jouer avec certains types de base courants.

Types d'élixir

Démarrez un Elixir REPL interactif en saisissant
> iex

Variable :

iex(1)> name = "rbin"
#=> "rbin"

Atomes :

Dans Elixir, un Atom est une constante dans laquelle son nom est sa propre valeur.
iex(2)> :this_is_an_atom
#=> :this_is_an_atom
iex(3)> :my_atom == :atom
#=> false

Tuples :

Nous utilisons la notation Curly Brace pour définir les tuples. Dans Elixir, les tuples sont stockés immédiatement en mémoire, ce qui signifie que l'obtention de la taille d'un tuple ou l'accès à un élément de tuple est rapide, mais la mise à jour ou l'ajout d'éléments est coûteux car il nécessite de copier tout le tuple en mémoire.

iex(4)> tuple = {:hello, "world"}
#=> {:hello, "world"}
iex(5)> elem(tuple, 1)
#=> "world"

Listes:

Dans Elixir, les listes sont stockées en mémoire, sous forme de listes chaînées. Nous pouvons mettre à jour les listes de manière triviale en ajoutant des éléments au début, mais l'ajout d'éléments est plus coûteux, car nous devons parcourir toute la liste pour déterminer sa taille.

iex(8)> list = [1, 2, :atom]
#=> [1, 2, :atom]
iex(9)> ["string"] ++ list
#=> ["string", 1, 2, :atom]
iex(10)> list ++ [31]
#=> [1, 2, :atom, 31]

Il existe des fonctions intégrées très utiles à utiliser avec les listes, notamment l'obtention de la tête et de la queue d'une liste.

iex(11)> hd(list)
#=> 1
iex(12)> tl(list)
#=> [2, :atom]

Fonctions anonymes :

Dans Elixir, les fonctions sont des citoyens de première classe, ce qui signifie que nous pouvons passer des fonctions comme arguments à d'autres fonctions. Ci-dessous, nous allons définir une variable nommée add qui contient une fonction, que nous passerons ensuite en argument à la fonction is_function/1 func .

iex(14)> add = fn a, b -> a + b end
#Function<12.90072148/2 in :erl_eval.expr/5>

iex(15)> add.(13, 31)
#=> 44

iex(16)> is_function(add)
#=> true

Organiser nos projets (Mix)

Elixir est livré avec un outil super utile nommé Mix. Mix est un outil de build qui nous permet de générer, organiser, compiler et tester très facilement nos projets. Cela nous permet également de gérer facilement les dépendances. (Toujours un sujet délicat !) Pour créer un nouveau projet avec Mix, nous procédons simplement comme suit :
~ mix new myapp --module MyApp
Cela créera un répertoire nommé myapp avec quelques fichiers à l'intérieur. Il définira également un module MyApp dans lib/myapp.ex .
* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/myapp.ex
* creating test
* creating test/test_helper.exs
* creating test/myapp_test.exs


Your mix project was created successfully.
You can use mix to compile it, test it, and more:
cd myapp
mix test
Comme nous pouvons le voir, nous obtenons tous les fichiers nécessaires pour une structure de projet de base. Je pense que c'est l'une des fonctionnalités les plus intéressantes disponibles avec Elixir. Avoir des outils de gestion de projet est super utile et fait gagner beaucoup de temps.

Le fichier mix.exs est le fichier principal utilisé pour configurer notre projet et gérer les dépendances, etc. Nous obtenons un test/folder , dans lequel nous pouvons écrire des tests de type ruby ​​pour notre projet. Nous obtenons bien sûr un lib/folder , qui contient les fichiers sources de notre projet. Si nous exécutons le test de mixage sur notre application, nous obtenons ce qui suit :
$ mix test
Compiled lib/myapp.ex
Generated myapp.app
.
Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
1 tests, 0 failures
Randomized with seed 543313

Concurrence

Tout comme Erlang, Elixir utilise le modèle "Acteur" pour la concurrence. Tout notre code s'exécute dans Processes , et ces processus sont isolés les uns des autres. Nous pouvons créer des programmes entièrement simultanés dans Elixir en engendrant des processus et en envoyant et en recevant des messages entre eux.

Dans Elixir, nous démarrons les processus en utilisant la fonction spawn , qui prend une autre fonction comme argument.

iex(1)> spawn(fn -> IO.puts 1 + 1 end)
#=> 2
#PID<0.55.0>

Comme vous pouvez le voir, nous avons créé un processus qui a généré 1 + 1 et a également renvoyé son ID de processus. Le retour de cet ID de processus est utile, car nous pouvons l'affecter à une variable et l'utiliser pour envoyer des messages au processus. Avant de faire cela, nous devons créer un mécanisme de réception pour atteindre les messages que nous envoyons au processus. (Nous pouvons continuer et le faire dans notre session Interative Elixir , ligne par ligne.)

Une fois que nous avons fait cela, nous pouvons créer un processus qui évalue area_loop et l'affecter à pid .

pid = spawn(fn -> Geometry.area_loop() end)
#=> #PID<0.40.0>

Nous pouvons ensuite envoyer des messages au pid auxquels notre code prédéfini correspondra, selon qu'il reçoit l'atome :rectangle ou l'atome :circle .

send pid, {:rectangle, 2, 3}
#=> Area = 6
# {:rectangle,2,3}

send pid, {:circle, 2}
#=> Area = 12.56000000000000049738
# {:circle,2}

Nous pouvons vérifier si les processus sont toujours en cours d'exécution à l'aide de Process.alive ? une fonction.

Process.alive?(pid)
#=> false

Conclusion

Nous n'avons même pas effleuré la surface dans ce blog. Il y a tellement de fonctionnalités incroyables dans Elixir, j'espère que vous continuerez à le vérifier par vous-même. J'ai répertorié ci-dessous quelques ressources d'apprentissage pour vous aider tout au long du processus, mais avant de vous lancer et de plonger, voici certaines de mes choses préférées à propos d'Elixir :

  • C'était facile à comprendre, avec une syntaxe de type rubis et des primitives de type Erlang
  • Il y a une communauté fantastique derrière
  • Son modèle de concurrence m'est à la fois familier et très puissant
  • Mix est une aubaine et fait gagner BEAUCOUP de temps
  • Elixir nous encourage à tout documenter
  • Cela fait de la création d'applications distribuées un champ de bataille beaucoup moins déroutant
  • Je peux voir Elixir aller un LONG chemin.

Ressources

Certaines ressources que j'ai trouvées très utiles au cours de ma courte période d'apprentissage d'Elixir :

  • http://elixir-lang.org/getting-started/introduction.html
  • https://pragprog.com/book/elixir/programming-elixir
  • https://teamgaslight.com/blog/the-best-resources-for-learning-elixir
  • http://exercism.io

* Allez-y et sirotez cet Elixir ! – @rbin *