URL: https://linuxfr.org/users/linkdd/journaux/letlang-hommage-a-leonardo-pisano-fibonacci Title: [Letlang] Hommage à Leonardo Pisano Fibonacci Authors: David Delassus Date: 2022年05月23日T12:40:28+02:00 License: CC By-SA Tags: letlang, fibonacci et langage_de_programmation Score: 18 Bonjour Nal, Aujourd'hui, je vais te parler de la suite de Fibonacci en Letlang. Pour la table des matières, comme d'habitude: - [Encore un nouveau langage de programmation](https://linuxfr.org/users/linkdd/journaux/letlang-encore-un-nouveau-langage-de-programmation) - [Écrire un compilateur en Rust](https://linuxfr.org/users/linkdd/journaux/letlang-ecrire-un-compilateur-en-rust) - [Écrire un compilateur en Rust (partie 2)](https://linuxfr.org/users/linkdd/journaux/letlang-ecrire-un-compilateur-en-rust-partie-2) - [Faire la différence entre un nombre et une quantité](https://linuxfr.org/users/linkdd/journaux/letlang-faire-la-difference-entre-un-nombre-et-une-quantite) - [Écrire un compilateur en Rust (partie 3)](https://linuxfr.org/users/linkdd/journaux/letlang-ecrire-un-compilateur-en-rust-partie-3) - [Et si on rédigeait la spec ?](https://linuxfr.org/users/linkdd/journaux/letlang-et-si-on-redigeait-la-spec) # Prélude Pour ceux qui ne sont pas au courant, le programme Letlang `Hello World` compile : ``` module "hello.main"; pub func main() -> @ok { perform debug("hello world"); @ok; } ``` Cela utilise un *side effect* (effet de bord pour les francophones) intégré au **runtime** qui ne fait pas de type checking, il disparaîtra sûrement à l'avenir pour laisser sa place à une meilleure interface, mais pour l'instant cela fait le taf :) Ce programme prouve notamment que l'implémentation des effets de bords en utilisant [genawaiter](https://docs.rs/genawaiter/latest/genawaiter/) (implémentation des coroutines en Rust) fonctionne à merveille. Le compilateur (désormais [open source](https://github.com/linkdd/letlang)) est composé de 3 parties : - **le parseur**, écrit en Rust avec **LALRPOP** et **Logos**, j'en ai parlé dans les articles précédents de cette série - **le générateur de code**, écrit pour le moment en Python (histoire d'aller vite), s'occupe de générer le code Rust à partir de l'AST produit par le parseur - **le runtime**, écrit en Rust, est ajouté en tant que dépendance au code Rust généré par le compilateur Chaque module Letlang va générer une crate Rust, et l'ensemble des crates est ajouté à un workspace Cargo, permettant ainsi de compiler le tout assez facilement. C'est pas forcément définitif comme manière de faire, mais pour l'instant, ça marche niquel. # Mais qu'est-ce donc que Fibonacci ? La suite de Fibonacci est définie par : ``` fib(0) = 1 fib(1) = 1 fib(n) = fib(n - 1) + fib(n - 2) ``` C'est l'exemple parfait pour faire du *pattern matching* et de la *récursion*. C'est aussi le projet d'exemple parfait pour continuer dans la lancée du *Hello World*. # Le code Sans plus attendre : ``` module "fib.main"; func fib(n: int) -> int { match n { 0 => 1, 1 => 1, int => fib(n - 1) + fib(n - 2), }; } pub func main() -> @ok { perform debug(fib(5)); @ok; } ``` Comme précédemment, on utilise le *side effect* `debug(...) -> @ok` pour afficher le résultat. Le plus intéressant ici, c'est l'expression `match`. Elle prend en paramètre une expression (ici `n`), et dans son corps, un ensemble de clause. Chaque "pattern" est un type. On a ainsi en rust: ```rust let patternval = /* ... */; let clause_0_type = /* ... */; let clause_1_type = /* ... */; let clause_2_type = /* ... */; if clause_0_type.has(context.clone(), &patternval) { // ... } else if clause_1_type.has(context.clone(), &patternval) { // ... } else if clause_2_type.has(context.clone(), &patternval) { // ... } else { // throw exception } ``` Le code est plutôt simple, débile même je dirais. Dans le futur il sera bien évidemment possible de "binder" des variables dans le pattern, ce qui changera cette implémentation, mais pour le moment, cela fonctionne et me permet d'avancer :) Pour ce qui est de la récursion, pas d'unroll, pas de TCO (tail call optimization) pour le moment, donc `fib(-5)` générera un joli stack overflow. # La suite des événements Le procédé est simple, on prend un exemple de programme, et on fait en sorte qu'il compile. C'est pourquoi j'ai commencé par `hello-world` et que j'ai enchaîné avec `fibonacci`. Avec suffisamment d'exemple, on couvrira l'ensemble des fonctionnalités du langage, le rendant petit à petit plus utile! Ainsi, le prochain projet exemple sera [l'automate cellulaire à la règle 110](https://en.wikipedia.org/wiki/Rule_110), qui démontrera la "Turing Completeness" de Letlang. Tout est sur le dépôt [Github](https://github.com/linkdd/letlang). Les choses avancent lentement mais sûrement, cette nouvelle étape accomplie m'emplie de joie et d'espoir pour l'avenir de ce langage. Voilà Nal, c'est tout pour cette petite annonce, j'espère t'avoir transmis un peu de mon enthousiasme :)

AltStyle によって変換されたページ (->オリジナル) /