Tutoriel pour Haskell

Acte I

1. Introduction

2. Exemple de Fonction

-- Définition de la fonction sumList qui prend une liste d'entiers en entrée et retourne leur somme
sumList :: [Int] -> Int           -- Type de la fonction : liste d'entier en entrée, et retourne un entier
sumList [] = 0                    -- Cas de base : si la liste est vide, la somme est 0
sumList (x:xs) = x + sumList xs   -- Cas récursif : ajoute l'élément en tête de liste à la somme du reste de la liste

-- Exemple d'utilisation de la fonction
main = do
    let myList = [1, 2, 3, 4, 5]
    putStrLn $ "La somme de la liste " ++ show myList ++ " est " ++ show (sumList myList)

$ ghc sum.hs
[1 of 1] Compiling Main           ( sum.hs, sum.o )
Linking sum ...

$ ./sum
La somme de la liste [1,2,3,4,5] est 15

3. Principales Structures de Données en Haskell

-- Définition du type de données Person
data Person = Person String Int

-- Fonction pour afficher une personne
showPerson :: Person -> String
showPerson (Person name age) = "Nom: " ++ name ++ ", Age: " ++ show age

-- Exemple d'utilisation
main :: IO ()
main = do
    let alice = Person "Alice" 25
        ethan = Person "Ethan" 30
    putStrLn $ "Informations sur Alice : " ++ showPerson alice
    putStrLn $ "Informations sur Ethan : " ++ showPerson ethan

Informations sur Alice : Nom: Alice, Age: 25
Informations sur Ethan : Nom: Ethan, Age: 30

4. Principaux types en Haskell

5. Types Dérivés avec `type` et `newtype`

-- Définition d'un type dérivé pour représenter des noms d'utilisateur
type Username = String

-- Utilisation du type dérivé
showUsername :: Username -> String
showUsername username = "Nom d'utilisateur : " ++ username

main :: IO ()
main = do
    let user = "JohnDoe"
    putStrLn $ showUsername user

-- Définition d'un nouveau type dérivé pour représenter des âges d'utilisateurs
newtype Age = Age Int

-- Fonction pour afficher un âge
showAge :: Age -> String
showAge (Age age) = "Âge : " ++ show age

main :: IO ()
main = do
    let userAge = Age 30
    putStrLn $ showAge userAge

6. Différence entre `type` et `newtype`

7. Type `Maybe`

safeDivide :: Double -> Double -> Maybe Double
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)

main :: IO ()
main = do
    putStrLn "Enter two numbers:"
    num1 <- readLn
    num2 <- readLn
    case safeDivide num1 num2 of
        Just result -> putStrLn $ "Result of division: " ++ show result
        Nothing -> putStrLn "Cannot divide by zero!"

8. Opérateur `$`

-- Les deux expressions suivantes sont équivalentes :

-- Sans $
result1 = sum (map (+1) [1, 2, 3])

-- Avec $
result2 = sum $ map (+1) [1, 2, 3]

9. La fonction `foldl`, fonction de pliage gauche

foldl :: (b -> a -> b) -> b -> [a] -> b

-- Somme des éléments d'une liste
sumList :: [Int] -> Int
sumList xs = foldl (+) 0 xs

-- Concaténation de tous les éléments d'une liste de chaînes de caractères
concatList :: [String] -> String
concatList xs = foldl (++) "" xs

10. Correspondances de Motifs

describeMaybe :: Maybe Int -> String
describeMaybe x = case x of
    Nothing -> "No value"
    Just n  -> "The value is " ++ show n

describeTuple :: (Int, Int) -> String
describeTuple pair = case pair of
    (0, 0) -> "Both numbers are zero"
    (0, _) -> "First number is zero"
    (_, 0) -> "Second number is zero"
    _      -> "Neither number is zero"

data Shape = Circle Double | Rectangle Double Double

area :: Shape -> Double
area shape = case shape of
    Circle r          -> pi * r * r
    Rectangle width height -> width * height

11. Les Gardes

classify :: Int -> String
classify n
    | n < 0    = "Negative"
    | n == 0   = "Zero"
    | n > 0    = "Positive"

ticketPrice :: Int -> Double
ticketPrice age
    | age < 5    = 0.0   -- Gratuit pour les moins de 5 ans
    | age < 18   = 5.0   -- Tarif réduit pour les moins de 18 ans
    | age < 65   = 10.0  -- Tarif normal pour les 18-64 ans
    | otherwise  = 7.0   -- Tarif réduit pour les 65 ans et plus

describeList :: [a] -> String
describeList xs = case xs of
    []   -> "The list is empty."
    [x]  -> "The list has one element."
    xs   -> "The list has " ++ show (length xs) ++ " elements."

describeList :: [a] -> String
describeList xs
    | null xs        = "The list is empty."
    | length xs == 1 = "The list has one element."
    | otherwise      = "The list has " ++ show (length xs) ++ " elements."

12. L'Interpréteur Interactif

$ ghci
GHCi, version 8.8.4, :? for help

Prelude> print "hello"
"hello"

Prelude> :type print
print :: Show a => a -> IO ()

Prelude> 2 + 2
4

Prelude> square x = x * x

Prelude> square 6
36

Prelude> :type square
square :: Num a => a -> a

Leaving GHCi.

13. Classe de type `Num a`

14. Contraintes de classe de type

foo :: Num a => a -> a

15. Initialisser une liste de 12 nombres aléatoires

import System.Random
import Control.Monad (replicateM)

-- Génère une liste de 12 nombres aléatoires entre 0 et 100 inclus
randomNumbers :: IO [Int]
randomNumbers = replicateM 12 $ randomRIO (0, 100)

main :: IO ()
main = do
    numbers <- randomNumbers
    print numbers

$ ghc r.hs -package random
[1 of 1] Compiling Main             ( r.hs, r.o )
Linking r ...

$ ./r
[37,99,100,64,28,93,67,53,60,25,33,19]

16. Quelques fonctions de traitement de base sur les listes

$ ghci
GHCi, version 8.8.4, :? for help

Prelude> li = [1,2,3,4,5,6]

Prelude> take 2 li
[1,2]

Prelude> drop 2 li
[3,4,5,6]

Prelude> reverse li
[6,5,4,3,2,1]

Prelude> map (+ 2) li
[3,4,5,6,7,8]

Prelude> foldl (\acc x -> acc + x) 0 li
21

Prelude> filter (\x -> (x `mod` 2) == 0) li
[2,4,6]

Prelude> 5 `elem` li  -- test la présence d'un élément dans une liste
True

Prelude> 12 `elem` li
False

Prelude> length li
6

Prelude> [0, 100] ++ li
[0,100,1,2,3,4,5,6]

Prelude> any (\x -> x `mod` 2 == 0) [1, 3, 5, 7]
False

Prelude> import Data.List (find)

Prelude Data.List> find (\x -> x == 4) li
Just 4

Prelude Data.List> :type find
find :: Foldable t => (a -> Bool) -> t a -> Maybe a

17. Nommer les champs d'une structure `data`

data Person = Person { firstName :: String,
                       lastName :: String,
                       age :: Int,
                       email :: String
                     }

let john = Person { firstName = "John", lastName = "Doe", age = 30, email = "john@example.com" }

print (firstName john)  -- Affiche "John"
print (age john)  -- Affiche 30

18. Structure Update

$ ghci
GHCi, version 8.8.4, :? for help

Prelude> data Person = Person { firstName :: String, lastName :: String, age :: Int } deriving (Show)

Prelude> let john1 = Person { firstName = "John", lastName = "Doe", age = 30 }

Prelude> newAge person _age = person { age = _age }

Prelude> let john2 = newAge john1 31

Prelude> john2
Person {firstName = "John", lastName = "Doe", age = 31}

19. Les Types Algébriques de Données

data Shape =
    Circle Float
  | Rectangle Float Float
  | Triangle Float Float Float

let myCircle = Circle 5.0

area :: Shape -> Float
area shape = case shape of
  Circle r -> 3.14 * r * r
  Rectangle w h -> w * h
  Triangle a b c ->   -- calcul de l'aire d'un triangle
    let s = (a + b + c) / 2
    in sqrt (s * (s - a) * (s - b) * (s - c))

myTriangle :: Shape
myTriangle = Triangle 3.0 4.0 5.0

let triangleArea = area myTriangle

data Dir = Left | Right

20. Extraire une sous-chaîne

$ ghci
GHCi, version 8.8.4, :? for help

Prelude> let subStr s i j = take j (drop i s)

Prelude> let s = "Hello World"

Prelude> subStr s 0 5
"Hello"

Prelude> subStr s 3 5
"lo Wo"

Prelude> :t subStr
subStr :: [a] -> Int -> Int -> [a]

Prelude> :t s
s :: [Char]

21. Récursivité Terminale

-- not tail-rec
sumList1 li =
    case li of
        [] -> 0
        x:xs -> x + sumList1 xs

-- tail-rec
sumList2 li =
    let aux [] sum = sum
        aux (x:xs) sum = aux xs (x + sum)
    in aux li 0

main = do
    let li = [1,2,3,4,5,6]
    print $ sumList1 li
    print $ sumList2 li

22. L'Indentation en Haskell,

23. L'opérateur d'indexation

ghci> let list = [10, 20, 30, 40, 50]

ghci> list !! 0
10

ghci> list !! 2
30

ghci> list !! 4
50

ghci> list !! 5
*** Exception: Prelude.!!: index too large

main :: IO ()
main = do
  let numbers = [1, 2, 3, 4, 5]
  putStrLn $ "The first element is: " ++ show (numbers !! 0)
  putStrLn $ "The third element is: " ++ show (numbers !! 2)
  putStrLn $ "The fifth element is: " ++ show (numbers !! 4)

The first element is: 1
The third element is: 3
The fifth element is: 5

import qualified Data.Vector as V

main :: IO ()
main = do
  let numbers = V.fromList [1, 2, 3, 4, 5]
  putStrLn $ "The first element is: " ++ show (numbers V.! 0)
  putStrLn $ "The third element is: " ++ show (numbers V.! 2)
  putStrLn $ "The fifth element is: " ++ show (numbers V.! 4)

24. Le Type `IO ()`

main :: IO ()
main = putStrLn "Hello, World!"

main :: IO ()
main = do
    putStrLn "What is your name?"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

25. Les Exceptions

-- Fonction de division
divide :: Int -> Int -> Int
divide _ 0 = throw DivideByZero
divide x y = x `div` y

import Control.Exception (ArithException(..), tryJust, evaluate, throw)
import Control.Monad (guard)

-- Mettre la fonction divide ici.

main :: IO ()
main = do
    -- Attempting to divide by zero.
    result <- tryJust (\e -> guard (e == DivideByZero) >> return e) (evaluate (divide 10 0))
    case result of
        Left DivideByZero -> putStrLn "Division par zéro !"
        Right value -> putStrLn $ "Result: " ++ show value

import Control.Exception (ArithException(..), catch, evaluate)

-- Fonction de division
divide :: Int -> Int -> Int
divide x y = x `div` y

main :: IO ()
main = do
    putStrLn "Attempting to divide by zero."
    -- Evaluation de la division et gestion de l'exception
    (evaluate (divide 10 0) >>= print) `catch` handler

-- Gestionnaire d'exceptions
handler :: ArithException -> IO ()
handler DivideByZero = putStrLn "Caught exception: Division by zero"
handler exn = putStrLn $ "Caught another arithmetic exception: " ++ show exn

26. Installer des bibliothèques Haskell

$ sudo apt-get update

$ sudo apt-cache search ghc
ghc - The Glasgow Haskell Compilation system

$ sudo apt-get install ghc

$ sudo apt-cache search cabal
cabal-install - command-line interface for Cabal and Hackage

$ sudo apt-get install cabal-install

$ cabal update
Downloading the latest package list from hackage.haskell.org

$ cabal install --lib gloss

Acte II — Scène 1

27. Hello World avec SDL2

{-# LANGUAGE OverloadedStrings #-}
import SDL.Vect (V2(..), V4(..), Point(P))
import SDL (($=))
import qualified SDL
import Control.Monad (unless)

main :: IO ()
main = do
    SDL.initialize [SDL.InitVideo]
    window <- SDL.createWindow "Hello World" SDL.defaultWindow { SDL.windowInitialSize = V2 320 240 }
    SDL.showWindow window
    renderer <- SDL.createRenderer window (-1) SDL.defaultRenderer
    loop renderer
    SDL.destroyRenderer renderer
    SDL.destroyWindow window
    SDL.quit

loop :: SDL.Renderer -> IO ()
loop renderer = do
    SDL.rendererDrawColor renderer $= V4 0 0 255 255
    SDL.clear renderer
    SDL.rendererDrawColor renderer $= V4 0 0 0 255
    let squareRect = SDL.Rectangle (P (V2 80 60)) (V2 60 40)  -- pos:(80, 60), size:(60x40)
    --SDL.drawRect renderer (Just squareRect)
    SDL.fillRect renderer (Just squareRect)
    SDL.present renderer
    event_loop renderer

event_loop :: SDL.Renderer -> IO ()
event_loop renderer = do
    maybeEvent <- SDL.pollEvent
    case maybeEvent of
        Just event -> unless (SDL.eventPayload event == SDL.QuitEvent) (event_loop renderer)
        Nothing -> loop renderer

$ sudo apt-cache search sdl2
libghc-sdl2-dev - high- and low-level bindings to the SDL 2 library

$ sudo apt-get install libghc-sdl2-dev

ghc hello.hs -package sdl2