On prend la liste comme une structure de données et une fonction de mapping
simple
Code :
-- Définition d'un functor
instance Functor Liste where
fmap _ Vide = Vide
fmap f (Element x xs) = Element (f x) (fmap f xs)
-- Définition d'une structure de données Liste
data Liste a = Vide | Element a (Liste a) deriving Show
-- Exemple d'utilisation avec une fonction de mapping
ajouterUn :: Int -> Int
ajouterUn x = x + 1
main = do
let listeInitiale = Element 1 (Element 2 (Element 3 Vide))
let listeModifiee = fmap ajouterUn listeInitiale
print listeModifiee
Ce programme Haskell définit une instance de Functor pour une structure de données
Liste et montre comment utiliser fmap pour appliquer une fonction ( ajouterUn dans cet
exemple) à chaque élément de la liste.
Applicative
Import [Link]
Définition de deux fonctions
additionMaybe :: Maybe (Int -> Int -> Int)
additionMaybe = pure (+)
troisMaybe :: Maybe Int
troisMaybe = pure 3
cinqMaybe :: Maybe Int
cinqMaybe = pure 5
Utilisation de <*> pour appliquer la fonction addition sur les valeurs 3 et 5
Resultat :: Maybe Int
Resultat = additionMaybe <*> troisMaybe <*> cinqMaybe
Main :: IO ()
Main = print resultat
Dans cet exemple, additionMaybe est une valeur de type Maybe (Int -> Int -> Int) contenant
la fonction d’addition. troisMaybe et cinqMaybe sont des valeurs Maybe Int contenant
respectivement les nombres 3 et 5.
En utilisant l’opérateur <*>, nous appliquons la fonction d’addition sur les valeurs
troisMaybe et cinqMaybe. Le résultat final est Just 8, car 3 + 5 = 8.
Monad
Définition d’une fonction sûre de division
divisionSûre :: Float -> Float -> Maybe Float
divisionSûre _ 0 = Nothing
divisionSûre x y = Just (x / y)
Utilisation de la monade Maybe pour une division sûre
Resultat :: Maybe Float
Resultat = do
X <- return 10
Y <- return 5
Z <- divisionSûre x y
Return (z + 1)
Utilisation de >> pour ignorer le résultat de la première action
resultatSansPremier :: Maybe Float
resultatSansPremier = do
return 10
y <- return 5
divisionSûre 20 y
Utilisation de >>= pour chaîner les actions sans stocker de valeurs intermédiaires
resultatAvecBind :: Maybe Float
resultatAvecBind = return 10 >>= (\x ->
return 5 >>= (\y ->
divisionSûre x y >>= (\z ->
return (z + 1))))
main :: IO ()
main = do
print resultat
print resultatSansPremier
print resultatAvecBind
Dans cet exemple :
Resultat utilise return pour placer les valeurs 10 et 5 dans le contexte de la monade Maybe,
puis utilise divisionSûre pour effectuer une division sûre. Enfin, il retourne le résultat
augmenté de 1.
resultatSansPremier utilise >> pour ignorer le résultat de la première action (return 10), puis
exécute divisionSûre avec 20 comme numérateur.
resultatAvecBind utilise >>= (également appelé bind) pour chaîner les actions en utilisant des
fonctions lambda pour éviter de stocker des valeurs intermédiaires.