Comment créer sa première (vraie) application

Écrire des scripts, c’est bien, mais souvent, quand on développe du code, on a envie d’en créer une application, c’est-à-dire quelque chose que l’on peut exécuter.

On va ici reprendre l’exemple de notre gestion des modèles Mustache (voir ici)

On va utiliser Stack, un outil qui permet de construire des paquets Haskell (relativement) facilement.

1. Stack

Stack est disponible sur beaucoup de plateformes, si vous ne l’avez pas dans votre distribution Haskell, vous pouvez avoir accès aux instructions d’installation propres à votre système d’exploitation ici.

Pour construire un nouveau projet, il suffit d’exécuter la commande :

stack new project_name

qui va créer un répertoire project_name pré-rempli avec un modèle d’application par défaut.

name: mustachio
version: 0.1.0.0
synopsis: blablabla
description: blabla plus détaillé.
author: Nous !
maintainer: cestnous@example.com

2. Structure du projet

À l’intérieur du dossier généré, on remarque la structure suivante :

mustachio/
├── app/
│   └── Main.hs          # Point d'entrée principal de l'application
├── src/
│   └── Lib.hs           # Code de la librairie
├── test/
│   └── Spec.hs          # Suite de test
├── .gitignore           # Classique
├── LICENSE              # Classique
├── README.md            # Classique
├── Setup.hs             # Build script (optionnel)
├── stack.yaml           # Fichier de configuration Stack généré
├── package.yaml         # Métadonnées du paquet
└── mustachio.cabal      # Fichier cabal autogénéré

Pour se simplifier le travail pour cette première application, on va se concentrer sur app et src.

Dans le dossier app, on va venir mettre les différents points d’entrée de l’application, c’est-à-dire les différents programmes finaux qu’on va vouloir exécuter. Ici, on n’en aura qu’un seul pour le moment.

Dans le dossier src, on va trouver tout le code à proprement parler de notre application. C’est donc dans ce dossier qu’on va venir mettre toutes les différentes fonctions que l’on va utiliser dans le programme principal.

Il ne faut pas oublier que, comme dans la plupart des langages, Haskell n’est pas monolithique. Il est donc tout à fait possible (et même fortement conseillé) de construire des petits modules que l’on peut importer ailleurs.

3. Structure de notre projet

Pour mustachio, la structure finale du projet ressemble à :

mustachio/
├── app/
│   └── Main.hs                           # Point d'entrée
└── src/
    ├── Models/
    │   ├── CompleteMustacheModel.hs      # Modèle Mustache complet
    │   ├── JsonModel.hs                  # JSON
    │   └── MustacheModel.hs              # Modèle simple
    ├── Parser/                           # Module pour parser
    │   ├── Data/                         # Code pour parser les données
    │   │   └── JsonParser.hs
    │   ├── Template/                     # Code pour parser les modèles
    │   │   ├── CompleteTemplateParser.hs
    │   │   └── TemplateParser.hs
    │   ├── Parser.hs                     # Librairie de parseur
    │   └── Utils.hs                      # Fonction utiles
    ├── Program/                          # Module pour la gestion du programme
    │   ├── Errors.hs                     # Erreurs possibles
    │   ├── FileChecker.hs                # Vérifications dans les fichiers
    │   └── Options.hs                    # Options du programme
    ├── Renderer/                         # Module pour l'instanciation
    │   ├── MoreRender.hs
    │   ├── Render.hs
    │   └── Utils.hs
    └── Lib.hs

4. Installer le projet

On peut compiler un projet Stack en utilisant la commande stack build. Pour installer l’exécutable produit dans le PATH, on peut aussi utiliser stack install.

5. Points d’entrées multiples

On pourrait vouloir construire une application qui a plusieurs points d’entrée. Par exemple, dans notre cas, on pourrait vouloir utiliser le modèle simple de Mustache, qui ne prend en compte que les variables simples (chaînes, nombres, booléens).

Pour faire cela, on peut simplement écrire un deuxième module dans le dossier app, qui va importer les fonctions “simples” qu’on a écrites et qui va les exécuter.

Il faut ensuite déclarer ce nouvel exécutable dans le fichier package.yaml pour que Stack puisse le compiler également.

L’avantage d’avoir écrit un code modulaire : on n’a donc pas grand-chose à changer !