Debuter avec Haskell

Pourquoi Haskell ?

Haskell est une langue de programmation fonctionnelle pure, qui a été créée pour faciliter la conception de programmes fiables et évolutifs. Elle est principalement utilisée dans des domaines comme le traitement du langage naturel, l'apprentissage automatique et la recherche en informatique théorique.

Un cas d'usage concret est le développement d'un assistant virtuel sophistiqué qui comprend une variété de capacités, allant de la reconnaissance vocale à la gestion des rappels. Haskell permet d'écrire ce type de programme de manière modulaire et réutilisable, en utilisant ses outils puissants de programmation fonctionnelle.

Prerequis

• Connaissance de base du langage de programmation (JavaScript, Python, Java, etc.)
• Installation de GHC (Glasgow Haskell Compiler)

  # Installez GHC sur Ubuntu/Debian
  sudo apt-get update
  sudo apt-get install ghc
  

• Installation d'un éditeur de code fonctionnel comme VSCode, avec l'extension Haskero

Concepts fondamentaux

Fonction pure

Une fonction pure est une fonction qui, pour un certain ensemble de paramètres, retourne toujours le même résultat. Elle ne peut pas avoir d'effets secondaires (comme modifier des variables globales ou accéder à l'entrée/sortie).

## Exemple de fonction pure
add :: Int -> Int -> Int
add x y = x + y

-- Test
main = do
    print $ add 5 3  -- Affiche : 8

Fonction curryée

La curryfication est une technique qui permet d'appliquer une fonction à un seul argument à la fois, en retournant une nouvelle fonction pour chaque appel.

## Exemple de fonction curryée
multiply :: Int -> (Int -> Int)
multiply x y = x * y

-- Test
main = do
    let double = multiply 2
    print $ double 5  -- Affiche : 10

Fonction récursive

La programmation récursive est une technique qui permet de définir des fonctions en termes d'elle-même.

## Exemple de fonction récursive pour calculer la factorielle
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- Test
main = do
    print $ factorial 5  -- Affiche : 120

Mise en pratique : projet fil rouge

Nous allons construire un mini-projet complet, un gestionnaire de tâches simple. Ce programme permettra d'ajouter des tâches, les afficher et les marquer comme terminées.

Étape 1 : Définir le type Tache

-- Type pour une tâche
data Tache = Tache {
    description :: String,
    estTerminee :: Bool
} deriving (Show, Eq)

-- Exemple de création d'une tâche
tacheExemple = Tache "Faire les courses" False

Étape 2 : Définir les fonctions pour manipuler les tâches

-- Ajouter une tâche à la liste des tâches
ajouterTache :: [Tache] -> Tache -> [Tache]
ajouterTache taches nouvelleTache = nouvelleTache : taches

-- Marquer une tâche comme terminée
marquerCommeTerminee :: [Tache] -> Int -> [Tache]
marquerCommeTerminee [] _ = []
marquerCommeTerminee (tache:reste) index
    | index == 0 = tache { estTerminee = True } : reste
    | otherwise = tache : marquerCommeTerminee reste (index - 1)

-- Afficher toutes les tâches
afficherTaches :: [Tache] -> IO ()
afficherTaches taches = mapM_ print taches

-- Test du gestionnaire de tâches
main = do
    let tache1 = Tache "Faire les courses" False
        tache2 = Tache "Nettoyer la chambre" False
        toutesLesTaches = ajouterTache [tache1, tache2] (Tache "Lire un livre" False)
    
    putStrLn "Liste des tâches :"
    afficherTaches toutesLesTaches
    
    let nouvellesTaches = marquerCommeTerminee toutesLesTaches 0
    putStrLn "\nAprès avoir fait les courses :"
    afficherTaches nouvellesTaches

Étape 3 : Exécuter le programme

Pour exécuter le programme, enregistrez-le dans un fichier Main.hs et utilisez la commande suivante :

## Compilez et exécutez le programme
ghc -o gestionnaireTaches Main.hs
./gestionnaireTaches

Erreurs frequentes et debugging

Erreur 1 : Non typeable expression

Code incorrect :

main = do
    print (add 5 "3")

Erreur :

Non typeable expression: "3"

Correction :

main = do
    print (add 5 (read "3"))

Erreur 2 : Couldn't match expected type with actual type

Code incorrect :

ajouterTache :: [Int] -> Int -> [Int]
ajouterTache taches nouvelleTache = nouvelleTache : taches

main = do
    let taches = ajouterTache [1, 2, 3] "4"
    print taches

Erreur :

Couldn't match expected type with actual type: Couldn't match expected type 'Int' with actual type '[Char]'

Correction :

ajouterTache :: [Int] -> Int -> [Int]
ajouterTache taches nouvelleTache = nouvelleTache : taches

main = do
    let taches = ajouterTache [1, 2, 3] 4
    print taches

Erreur 3 : Variable not in scope

Code incorrect :

main = do
    afficherTache tacheExemple

Erreur :

Variable not in scope: afficherTache

Correction :

-- Ajouter une fonction pour afficher une tâche
afficherTache :: Tache -> IO ()
afficherTache tache = putStrLn $ description tache ++ (if estTerminee tache then " [Terminée]" else "")

main = do
    let tache1 = Tache "Faire les courses" False
        toutesLesTaches = ajouterTache [tache1] (Tache "Nettoyer la chambre" False)
    
    putStrLn "Liste des tâches :"
    mapM_ afficherTache toutesLesTaches

Pour aller plus loin

1. Comprendre les monads

Apprendre à utiliser les monads est essentiel pour travailler avec des actions asynchrones, des I/O et des structures de données complexes.

Lien vers le tutoriel Haskell Monads

2. Utiliser le système d'exploitation

Haskell peut être utilisé pour écrire des applications systèmes complexes en utilisant ses bibliothèques pour l'interaction avec le système d'exploitation.

Lien vers le tutoriel Haskell System

3. Optimiser les performances

Apprendre à optimiser les performances en utilisant des techniques spécifiques et des bibliothèques pour la gestion de la mémoire peut améliorer considérablement les applications Haskell.

Lien vers le tutoriel Haskell Performance

Défi pratique : Créer un CLI (Command Line Interface) pour un blog

Créez un simple CLI en Haskell qui permet d'ajouter des articles à un blog, de les afficher et de les marquer comme publiés.

Indice :

• Utilisez le type Article avec des champs title, content et estPublie.
• Implémentez des fonctions pour ajouter, afficher et publier des articles.
• Créez un simple menu en ligne de commande pour interagir avec votre CLI.

Ce tutoriel a couvert les concepts de base de Haskell et vous a montré comment construire un mini-projet complet. Avec ces connaissances, vous êtes maintenant prêt à approfondir votre apprentissage et à développer des applications plus complexes en utilisant Haskell.