Bases
Hello World
main est le point d'entrée, putStrLn affiche avec un saut de ligne
-- GHCi interactive environment
-- launch: ghci (quit with :q)
-- simple arithmetic
> 2 + 3
5
-- function application (no parentheses needed)
> succ 5
6
-- define a function
> double x = x * 2
> double 10
20
-- lists
> [1,2,3,4]
[1,2,3,4]
-- strings are lists of chars
> "hello"
"hello"Commentaires
{- -} pour les commentaires multi-lignes
-- single line comment
{- multi-line comment
spanning multiple lines -}
{- nested {- comments -} are allowed -}
-- comments are ignored by the compilerGHCi interactif
:t affiche le type, :q quitte
-- hello.hs
main :: IO ()
main = putStrLn "Hello, World!"
-- run interpreted
-- runhaskell hello.hs
-- or compile to an executable
-- ghc hello.hs && ./helloLiaison let
let définit des variables locales dans un bloc do
-- in GHCi, 'let' defines a binding (no 'in' needed)
> let x = 5
> let double n = n * 2
> x + double x
15
-- in a source file, top-level bindings need no 'let'
y = 10
-- 'let' inside an expression needs 'in'
z = let a = 2 in a * a -- 4Règles d'indentation
Haskell utilise l'indentation au lieu des accolades
-- :t shows the type of an expression
> :t 'a'
'a' :: Char
> :t True
True :: Bool
> :t "hi"
"hi" :: [Char]
> :t (+)
(+) :: Num a => a -> a -> a
-- :info shows typeclass info
> :info NumCharger des fichiers
:load charge un module dans GHCi ; :reload le recharge après édition. :browse liste tout ce qu'un module exporte. :main exécute le programme avec des arguments de ligne de commande. Ces commandes fluidifient le workflow du REPL.
-- GHCi commands
> :load MyModule.hs -- or :l
> :reload -- or :r, reload after edits
> :type main -- check a type
> :browse Data.List -- list a module's exports
> :main arg1 arg2 -- run main with args
-- :set +t auto-prints types of resultsTypes
Types de base
:: annote explicitement les types
-- Int: bounded integer (platform-dependent)
x :: Int
x = 9
-- Integer: arbitrary-precision (unbounded)
big :: Integer
big = 2 ^ 100
-- Float / Double (prefer Double)
piVal :: Double
piVal = 3.14159
-- Bool
flag :: Bool
flag = True
-- Char (single Unicode character)
c :: Char
c = 'a'Types de fonctions
-> est associatif à droite, le dernier est le type de retour
-- explicit type signature above a binding
age :: Int
age = 30
-- annotate an expression inline with ::
result = (5 :: Int) + 3
-- function signature
add :: Int -> Int -> Int
add x y = x + y
-- annotate a list
nums :: [Double]
nums = [1.0, 2.0, 3.0]Variables de type
Les lettres minuscules sont des variables de type
-- 'a' is a type variable (polymorphic)
id' :: a -> a
id' x = x
-- works for any type
> id' 5
5
> id' "hello"
"hello"
-- length works on any list
length :: [a] -> IntType Maybe
Maybe représente des calculs qui peuvent échouer
-- '->' is right-associative
add :: Int -> Int -> Int
-- equivalent to: Int -> (Int -> Int)
-- takes a function as an argument
apply :: (a -> b) -> a -> b
apply f x = f x
-- returns a function
const' :: a -> b -> a
const' x y = xType Either
Either est utilisé pour la gestion des erreurs
-- Maybe: optional values
data Maybe a = Nothing | Just a
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- Either: a value or an error
data Either a b = Left a | Right b
-- convention: Left = error, Right = success
parse :: String -> Either String Int
parse s = Right (read s)Tuples et types de listes
Les tuples (a, b) portent un nombre fixe de valeurs de types possiblement différents. Les listes [a] portent un nombre quelconque de valeurs du même type. Le type d'un tuple encode sa taille ; pas celui d'une liste.
-- tuple: (a, b)
pair :: (Int, String)
pair = (1, "one")
-- list: [a]
nums :: [Int]
nums = [1, 2, 3]
-- list of tuples
pairs :: [(Int, String)]
pairs = [(1, "a"), (2, "b")]
-- empty list keeps the polymorphic type
empty :: [a]
empty = []Classes de types
Classe de type Eq
Eq définit la comparaison d'égalité
-- name, parameters, '=', body
double :: Int -> Int
double x = x * 2
-- application: just a space, no parentheses
> double 5
10
-- multiple parameters (curried)
add :: Int -> Int -> Int
add x y = x + y
> add 3 4
7Show et Read
Classes de types Show/Read
-- application is left-associative
> max 3 5
5
> max (max 3 5) 7
7
-- '$' has the lowest precedence, right-associative
> sum (map (*2) [1..5])
30
> sum $ map (*2) [1..5] -- same, fewer parens
-- chain reads left to right
> putStrLn $ show $ sum [1..10]
55Num et Ord
Num pour les opérations numériques, Ord pour la comparaison d'ordre
-- wrap an operator in () to use as a function
> (+) 2 3
5
> (*) 4 5
20
-- sections: partial application of operators
> (+10) 5
15
> (3/) 12
0.25
> (/3) 12
4.0
-- backticks make a function infix
> 10 `div` 3
3
> 10 `mod` 3
1Classe de type Functor
Functor est mappable
-- (.) composes functions right to left
(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = f (g x)
> negate . sum $ [1,2,3]
-6
-- chaining
fn = ceiling . negate . tan
> fn (pi/4)
-1
-- point-free style
odd' = not . evenContraintes de type
À gauche de => se trouve la contrainte de type
-- functions are first-class values
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
> applyTwice (+3) 10
16
> applyTwice (\x -> x*x) 2
16
-- pass functions to higher-order functions
> map (*2) [1..5]
[2,4,6,8,10]
> filter even [1..6]
[2,4,6]Infixe et préfixe
Toute fonction binaire peut s'écrire infixe entre backticks (3 `elem` xs), et tout opérateur peut s'écrire préfixe entre parenthèses (mod 10 3). Choisissez ce qui se lit le plus naturellement dans le contexte.
-- infix operators can be written prefix with ()
> mod 10 3
1
> div 10 3
3
-- functions can be written infix with backticks
> 10 `mod` 3
1
> 10 `div` 3
3
-- elem: membership test, often infix
> 3 `elem` [1,2,3]
TrueFonctions
Définition de fonction
Les appels de fonction n'ont pas besoin de parenthèses
-- lists are homogeneous linked lists
nums :: [Int]
nums = [1, 2, 3, 4, 5]
-- strings are [Char]
chars = ['h','e','l','l','o']
str = "hello" -- same as chars
-- empty list
empty = []
-- cons (prepend) is O(1)
> 0 : [1,2,3]
[0,1,2,3]Fonctions multi-paramètres
Toutes les fonctions sont à paramètre unique (curryfiées)
-- ranges
> [1..5]
[1,2,3,4,5]
-- with a step (first two elements)
> [2,4..10]
[2,4,6,8,10]
-- decreasing needs the step
> [5,4..1]
[5,4,3,2,1]
-- infinite lists (lazy)
> take 5 [1..]
[1,2,3,4,5]
> take 3 (cycle [1,2])
[1,2,1]Opérateurs comme fonctions
() enveloppe un opérateur comme fonction
-- basic access (partial: crash on empty)
> head [1,2,3]
1
> tail [1,2,3]
[2,3]
> last [1,2,3]
3
> init [1,2,3]
[1,2]
-- safe helpers
> length [1,2,3]
3
> null []
True
> reverse [1,2,3]
[3,2,1]Composition de fonctions
. opérateur compose les fonctions
-- '++' concatenates two lists
> [1,2] ++ [3,4]
[1,2,3,4]
-- ':' prepends a single element (O(1))
> 1 : [2,3]
[1,2,3]
-- concat flattens one level
> concat [[1,2],[3,4],[5]]
[1,2,3,4,5]
-- intercalate joins with a separator
> intercalate ", " ["a","b","c"]
"a, b, c"Clause where
where définit des aides en bas d'une fonction
-- like mathematical set-builder notation
> [x*2 | x <- [1..5]]
[2,4,6,8,10]
-- with a predicate (filter)
> [x | x <- [1..10], even x]
[2,4,6,8,10]
-- multiple generators = Cartesian product
> [(x,y) | x <- [1,2], y <- ['a','b']]
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- with a let binding
> [x*y | x <- [1..3], let y = x+1]
[2,6,12]Fonctions de liste courantes
elem vérifie l'appartenance (souvent infixe). sum et product réduisent des listes de nombres. take/drop extraient ou retirent un préfixe. splitAt scinde à un index en une paire. Tout renvoie de nouvelles listes puisque les listes sont immuables.
-- membership (often written infix)
> elem 3 [1,2,3]
True
> 3 `elem` [1,2,3]
True
-- reductions
> sum [1..10]
55
> product [1..5]
120
-- take / drop a prefix
> take 3 [1..10]
[1,2,3]
> drop 3 [1..10]
[4,5,6,7,8,9,10]
-- split at an index
> splitAt 3 [1..6]
([1,2,3],[4,5,6])Filtrage par motif
Filtrage par motif de base
Correspondance dans l'ordre, _ correspond à tout
-- tuples can hold different types
pair :: (Int, String)
pair = (1, "hello")
triple :: (Int, String, Double)
triple = (1, "x", 3.14)
-- the size is part of the type
-- (1,2) and (1,2,3) are different typesFiltrage par motif de liste
: sépare la tête et la queue
-- fst/snd only work on pairs
> fst (1, "a")
1
> snd (1, "a")
"a"
-- swap exchanges the components
> swap (1, 2)
(2,1)
-- these do NOT work on triples
> fst (1, 2, 3) -- type error!Filtrage par motif de tuple
Correspondance à chaque position d'un tuple
-- destructure a tuple by position
describe :: (Int, String) -> String
describe (n, s) = show n ++ ": " ++ s
-- ignore components with _
firstOf :: (a, b, c) -> a
firstOf (x, _, _) = x
-- in a list comprehension
> [n | (n, _) <- [(1,'a'),(2,'b')]]
[1,2]Motif as
@ conserve toute la valeur correspondante
-- zip pairs elements from two lists
> zip [1,2,3] ['a','b','c']
[(1,'a'),(2,'b'),(3,'c')]
-- stops at the shorter list
> zip [1,2,3] [4,5]
[(1,4),(2,5)]
-- unzip splits a list of pairs
> unzip [(1,'a'),(2,'b')]
([1,2],"ab")Expression case
case pour le filtrage par motif dans un corps de fonction
-- list: same type, variable length
ints :: [Int]
ints = [1, 2, 3]
-- tuple: mixed types, fixed length
mixed :: (Int, String, Bool)
mixed = (1, "x", True)
-- list of tuples (tabular data)
people :: [(String, Int)]
people = [("Alice",30),("Bob",25)]
-- cannot mix types in a list
> [1, "two"] -- type errorGardes
Gardes de base
otherwise est un alias pour True
-- match on literals, top to bottom
lucky :: Int -> String
lucky 7 = "LUCKY SEVEN!"
lucky _ = "Sorry, you're out of luck"
> lucky 7
"LUCKY SEVEN!"
> lucky 13
"Sorry, you're out of luck"Gardes multi-paramètres
Les gardes vérifient dans l'ordre
-- empty list
isEmpty [] = True
isEmpty _ = False
-- head and tail (cons pattern)
head' :: [a] -> a
head' (x:_) = x
-- first two elements
firstTwo :: [a] -> [a]
firstTwo (x:y:_) = [x,y]
firstTwo xs = xswhere avec gardes
where peut être partagé par toutes les gardes
-- match by position
addPair :: (Int, Int) -> Int
addPair (x, y) = x + y
-- nested patterns
getAge :: (String, (Int, Int)) -> Int
getAge (_, (age, _)) = age
-- ignore with _
nameOf :: (String, Int) -> String
nameOf (name, _) = nameMotifs as
Les as-patterns (name@pattern) lient un nom à la valeur entière matchée tout en la déstructurant. Utile quand on a besoin à la fois de l'original et de ses parties, en évitant une reconstruction coûteuse.
-- '@' keeps the whole value AND its parts
firstLetter :: String -> String
firstLetter "" = "Empty string!"
firstLetter all@(x:_) =
"The first letter of " ++ all ++ " is " ++ [x]
> firstLetter "Haskell"
"The first letter of Haskell is H"Expressions case
case effectue du pattern matching dans une expression. Utile quand le corps d'une fonction doit brancher sur une valeur calculée après un préambule. Les motifs sont essayés dans l'ordre ; ajoutez un fourre-tout au besoin.
-- pattern match inside any expression
describe :: [a] -> String
describe xs =
case xs of
[] -> "empty"
[_] -> "singleton"
_ -> "longer"
-- case on any value, e.g. an Ordering
classify n = case compare n 0 of
LT -> "negative"
EQ -> "zero"
GT -> "positive"Motifs de constructeurs
Les motifs peuvent matcher des constructeurs de données comme Red, Nothing et Just. C'est ainsi qu'on déconstruit les types algébriques de données. Le compilateur avertit des motifs non exhaustifs, couvrez donc tous les constructeurs.
-- match on data constructors
data Color = Red | Green | Blue
toString :: Color -> String
toString Red = "red"
toString Green = "green"
toString Blue = "blue"
-- match on Maybe
fromMaybe :: a -> Maybe a -> a
fromMaybe d Nothing = d
fromMaybe _ (Just x) = xWhere / Let
Clause where
where se trouve en bas d'une définition de fonction
-- '|' tests boolean conditions in order
bmiTell :: Double -> String
bmiTell bmi
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| bmi <= 30.0 = "overweight"
| otherwise = "obese"
> bmiTell 22.0
"normal"Expression let-in
let-in est une expression, peut être utilisé n'importe où
-- otherwise is just True
otherwise :: Bool
otherwise = True
-- a signum implementation
signum' :: Int -> Int
signum' n
| n < 0 = -1
| n == 0 = 0
| otherwise = 1let dans un bloc do
let dans un bloc do n'a pas besoin de in
-- multiple parameters
max' :: Int -> Int -> Int
max' a b
| a > b = a
| otherwise = b
-- shared helpers via where
bmiTell :: Double -> Double -> String
bmiTell w h
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| otherwise = "overweight"
where bmi = w / h^2let dans une compréhension de liste
let peut être utilisé dans les compréhensions de liste
-- pattern matching: fixed values/structure
factorial 0 = 1
factorial n = n * factorial (n-1)
-- guards: ranges and conditions
clamp :: Int -> Int -> Int -> Int
clamp lo hi x
| x < lo = lo
| x > hi = hi
| otherwise = xif-then-else
En Haskell, 'if' est une expression qui renvoie toujours une valeur — les deux branches sont requises. Pour des branches multiples, les guards sont plus propres que des if-then-else imbriqués. if-then-else convient aux choix simples à deux voies.
-- 'if' is an expression that returns a value
abs' :: Int -> Int
abs' n = if n < 0 then -n else n
-- nested ifs (prefer guards for readability)
grade :: Int -> Char
grade n =
if n >= 90 then 'A'
else if n >= 80 then 'B'
else if n >= 70 then 'C'
else 'F'Listes
Bases des listes
Les listes sont des listes chaînées d'éléments de même type
-- where: definitions at the bottom, scoped to a function
area :: Double -> Double -> Double
area w h = w * h_adj
where
h_adj = h * 0.9 -- adjust height
scale = 0.9 -- a helper
-- definitions can refer to each other
f x = a + b
where a = x * 2
b = a + 1 -- refers to aListes par intervalle
Supporte les pas et les listes infinies
-- let <bindings> in <expr>
cylinder :: Double -> Double -> Double
cylinder r h =
let side = 2 * pi * r * h
top = pi * r^2
in side + 2 * top
-- scoped to the expression only
> let z = 5 in z * z
25
-- z is not in scope hereOpérations sur les listes
Fonctions d'opération de liste de base
-- in do, 'let' needs no 'in'
main = do
let x = 5
y = 10
putStrLn $ "sum = " ++ show (x + y)
-- in a list comprehension, no 'in'
> [x*y | x <- [1..3], let y = x+1]
[2, 6, 12]Concaténation de listes
++ concatène, : ajoute en tête
-- where bindings support pattern matching
describe :: [a] -> String
describe xs = "head is " ++ show first
where (first:_) = xs
-- multiple where bindings
analyze :: [Int] -> String
analyze xs =
"sum=" ++ show s ++ ", len=" ++ show l
where s = sum xs
l = length xsCompréhension de liste
Similaire aux compréhensions d'ensembles mathématiques
-- let: an expression, available wherever expressions go
-- (needs 'in', except in do/comprehension)
-- where: a declaration, attached to a function
-- (cannot be nested as an expression)
-- same result, two styles:
-- with let:
f x = let y = x+1 in y*y
-- with where:
f' x = y*y where y = x+1Tuples
Bases des tuples
Les tuples peuvent contenir différents types
-- base case + recursive case
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)
> factorial 5
120Fonctions de tuple
fst/snd ne fonctionnent que sur les paires
-- match [] then (x:xs)
length' :: [a] -> Int
length' [] = 0
length' (_:xs) = 1 + length' xs
sum' :: Num a => [a] -> a
sum' [] = 0
sum' (x:xs) = x + sum' xsFiltrage par motif de tuple
Le filtrage par motif déstructure les tuples
-- carry the running result in an accumulator
factorial :: Int -> Int
factorial n = go n 1
where
go 0 acc = acc
go k acc = go (k-1) (k*acc)
-- sum with an accumulator
sumTo :: Int -> Int
sumTo n = go n 0
where go 0 acc = acc
go k acc = go (k-1) (k+acc)Tri rapide
Ce fameux exemple montre l'expressivité de Haskell : des compréhensions de listes scindent autour d'un pivot, puis trient récursivement chaque partie. Ce n'est pas le quicksort le plus efficace, mais une belle démonstration de récursion et de compréhensions.
-- elegant but not in-place quicksort
qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (p:xs) =
qsort smaller ++ [p] ++ qsort larger
where
smaller = [x | x <- xs, x < p]
larger = [x | x <- xs, x >= p]
> qsort [3,1,4,1,5,9,2,6]
[1,1,2,3,4,5,6,9]Récursion mutuelle
La récursion mutuelle survient quand deux fonctions ou plus s'appellent mutuellement. Ici even' et odd' réduisent vers le cas de base 0. Les deux doivent être définies (l'ordre n'importe pas dans un module).
-- functions calling each other
even' :: Int -> Bool
even' 0 = True
even' n = odd' (n - 1)
odd' :: Int -> Bool
odd' 0 = False
odd' n = even' (n - 1)
> even' 4
TrueFonctions d'ordre supérieur
map
map applique une fonction à chaque élément
-- map applies a function to every element
> map (*2) [1,2,3]
[2,4,6]
> map (+1) [1..5]
[2,3,4,5,6]
-- with a lambda
> map (\x -> x*x) [1..4]
[1,4,9,16]
-- strings are lists of chars
> map toUpper "hello"
"HELLO"filter
filter garde les éléments qui satisfont le prédicat
-- keep elements satisfying a predicate
> filter even [1..10]
[2,4,6,8,10]
> filter (>3) [1,2,3,4,5]
[4,5]
-- with a lambda
> filter (\c -> c /= ' ') "hello world"
"helloworld"
-- count matches
> length (filter odd [1..100])
50foldl et foldr
foldl pli à gauche, foldr pli à droite
-- foldl: left fold (function, seed, list)
> foldl (+) 0 [1..5]
15
-- foldr: right fold
> foldr (+) 0 [1..5]
15
-- associativity differs:
-- foldl: ((((0+1)+2)+3)+4)+5
-- foldr: 1+(2+(3+(4+(5+0))))
-- foldl1/foldr1 use the first element as seed
> foldl1 max [3,1,4,1,5]
5zipWith
zipWith combine deux listes avec une fonction
-- apply a function to paired elements
> zipWith (+) [1,2,3] [10,20,30]
[11,22,33]
> zipWith (*) [1,2,3,4] [2,2,2,2]
[2,4,6,8]
-- combine strings
> zipWith (\a b -> a ++ b) ["a","b"] ["1","2"]
["a1","b2"]
-- stops at the shorter list
> zipWith max [1,5,3] [2,4,6,8]
[2,5,6]Application de fonction $
L'opérateur $ réduit les parenthèses
-- scanl returns all intermediate accumulators
> scanl (+) 0 [1,2,3]
[0,1,3,6]
-- scanr from the right
> scanr (+) 0 [1,2,3]
[6,5,3,0]
-- running maximum
> scanl max 0 [3,1,4,1,5]
[0,3,3,4,4,5]takeWhile et dropWhile
takeWhile s'arrête au premier élément faillant au prédicat ; dropWhile retire le préfixe qui le satisfait. span scinde une liste au premier élément fautif. Parfait pour le traitement par préfixe.
-- takeWhile: take while the predicate holds
> takeWhile (<5) [1,2,3,4,5,4,3]
[1,2,3,4]
-- dropWhile: drop while the predicate holds
> dropWhile (<5) [1,2,3,4,5,4,3]
[5,4,3]
-- span splits at the first failing element
> span (<3) [1,2,3,4,5]
([1,2],[3,4,5])
-- first word of a string
> takeWhile (/= ' ') "hello world"
"hello"Map / Filter / Fold
Opérations chaînées
Combiner map/filter/fold
-- '\' defines a lambda (resembles the λ symbol)
> (\x -> x + 1) 5
6
-- used with map
> map (\x -> x * x) [1..4]
[1,4,9,16]
-- used with filter
> filter (\x -> x > 2) [1,2,3,4]
[3,4]scanl/scanr
scan conserve tous les résultats intermédiaires
-- parameters separated by spaces
> (\x y -> x + y) 3 4
7
-- in zipWith
> zipWith (\x y -> x * y + 1) [1,2,3] [10,20,30]
[11,21,31]takeWhile/dropWhile
Prendre/ignorer des éléments par condition
-- lambdas can pattern match their one argument
> map (\(a,b) -> a + b) [(1,2),(3,4)]
[3,7]
-- only ONE pattern, no fallthrough
-- this crashes if it doesn't match:
> (\(x:_) -> x) [] -- runtime errorLambdas en ordre supérieur
Les lambdas brillent avec fold, filter et map. Elles peuvent renvoyer d'autres fonctions (\x -> \y -> ...), illustrant le currying. Gardez-les courtes — les longues lambdas sont plus claires en fonctions nommées.
-- combining with fold
> foldl (\acc x -> acc + x*2) 0 [1,2,3]
12
-- with filter (infix via backticks)
> length . filter (\x -> x `mod` 2 == 0) $ [1..10]
5
-- a lambda returning a function
> (\x -> \y -> x + y) 3 4
7Style point-free
Le style point-free omet les arguments explicites, exprimant les fonctions par composition et application. Concis mais peut nuire à la lisibilité si exagéré. Réservez-le aux chaînes courtes où le flux est évident.
-- explicit: name every argument
sumSquares xs = sum (map (^2) xs)
-- point-free: omit arguments via composition
sumSquares' = sum . map (^2)
-- more examples
count p = length . filter p
oddNums = filter odd
negateAll = map negateLambdas
Fonctions anonymes
\ définit une lambda, comme λ
-- all functions are curried (one arg at a time)
add :: Int -> Int -> Int
add x y = x + y
-- apply fewer args to get a function
add5 :: Int -> Int
add5 = add 5
> add5 10
15
-- with map
> map (add 5) [1,2,3]
[6,7,8]Lambda multi-paramètres
Plusieurs paramètres séparés par des espaces
-- left section (fix the left operand)
> map (+3) [1,2,3]
[4,5,6]
-- right section (fix the right operand)
> map (3/) [9, 12, 18]
[0.333..,0.25,0.166..]
-- (-3) is the NUMBER, not a section!
> map (subtract 3) [4,5,6]
[1,2,3]
-- comparison sections
> filter (>3) [1..6]
[4,5,6]Lambda avec filtrage par motif
Filtrage par motif dans les lambdas
-- flip swaps the first two arguments
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
-- fix the second argument instead of the first
> map (flip (-) 1) [3,4,5]
[2,3,4]
-- divide from the other side
> map (flip div 2) [4,6,9]
[2,3,4]Le currying expliqué
a -> b -> c signifie a -> (b -> c) : une fonction qui prend 'a' et renvoie une fonction. L'application est associative à gauche : f x y = (f x) y. Voilà pourquoi l'application partielle fonctionne naturellement.
-- this signature:
max :: Int -> Int -> Int
-- is actually: Int -> (Int -> Int)
-- max takes an Int and returns a function
-- step by step
> :t max 5
max 5 :: Int -> Int
> (max 5) 10
10
-- application is left-associative
> max 5 10 == ((max 5) 10)
TrueFonctions renvoyant des fonctions
Les fonctions peuvent renvoyer d'autres fonctions, découlant naturellement du currying. Cela permet des factories de fonctions : multiplyBy 2 crée un doubleur. Une application partielle comme greet "Hi" configure une fonction pour un usage ultérieur.
-- return a function
multiplyBy :: Int -> (Int -> Int)
multiplyBy n = \x -> n * x
-- or equivalently (currying)
multiplyBy' n x = n * x
> let double = multiplyBy 2
> double 21
42
-- configure a function via partial application
greet :: String -> String -> String
greet greeting name = greeting ++ ", " ++ name
sayHi = greet "Hi" -- a configured greeterCurryfication
Application partielle
Toutes les fonctions sont automatiquement curryfiées
-- Eq: equality
> 5 == 5
True
> "a" /= "b"
True
-- Ord: ordering
> 3 < 5
True
> compare 3 5
LT
-- Show: convert to a string
> show 5
"5"
> show [1,2,3]
"[1,2,3]"
-- Read: parse from a string
> read "5" + 2
7Application partielle infixe
Application partielle des opérateurs
-- '=>' constrains the type variables
(==) :: Eq a => a -> a -> Bool
(<) :: Ord a => a -> a -> Bool
show :: Show a => a -> String
-- a function requiring Eq
elem :: Eq a => a -> [a] -> Bool
elem _ [] = False
elem x (y:ys) = x == y || elem x ys
-- multiple constraints
showMax :: (Ord a, Show a) => [a] -> String
showMax xs = show (maximum xs)Fonction flip
flip échange l'ordre des arguments
-- declare a typeclass with method signatures
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
-- default implementations
x == y = not (x /= y)
x /= y = not (x == y)
-- minimal: define either (==) or (/=)Déclarations d'instances
instance Typeclass Type where implémente une typeclass pour un type. Chaque méthode doit être définie, sauf défaut existant. Après cela, les valeurs TrafficLight peuvent employer ==, /= et show.
data TrafficLight = Red | Yellow | Green
instance Eq TrafficLight where
Red == Red = True
Yellow == Yellow = True
Green == Green = True
_ == _ = False
instance Show TrafficLight where
show Red = "Red light"
show Yellow = "Yellow light"
show Green = "Green light"Typeclasses numériques
La hiérarchie numérique inclut Num (tous les nombres), Fractional (gère /) et Integral (gère div, mod). Int et Double sont des types différents — utilisez fromIntegral pour convertir entre eux en toute sécurité.
-- Num: basic numeric operations
(+) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
-- Fractional: supports division
(/) :: Fractional a => a -> a -> a
-- Integral: integer division
div, mod :: Integral a => a -> a -> a
-- convert between numeric types
> fromIntegral (length [1,2,3]) + 0.5
3.5Deriving
Beaucoup de typeclasses se dérivent automatiquement : Eq, Ord, Show, Read, Enum, Bounded. Cela évite d'écrire des instances répétitives. Enum et Bounded activent la syntaxe de plage ([Red ..]) et minBound/maxBound.
-- automatically derive common typeclasses
data Color = Red | Green | Blue
deriving (Eq, Ord, Show, Read, Enum, Bounded)
> show Red
"Red"
> Red < Green
True
> minBound :: Color
Red
> [Red ..]
[Red,Green,Blue]Composition
Composition de fonctions
. compose de droite à gauche
-- sum type: alternatives separated by '|'
data Bool' = False' | True'
-- pattern match on constructors
not' :: Bool' -> Bool'
not' True' = False'
not' False' = True'
-- value constructors with no fields
data Weekday = Mon | Tue | Wed | Thu | FriComposition multi-fonctions
Composer en chaîne plusieurs fonctions
-- product type: constructors carry fields
data Point = Point Double Double
data Shape
= Circle Double -- radius
| Rect Double Double -- width, height
-- construct values
p = Point 1.0 2.0
c = Circle 5.0
r = Rect 3.0 4.0Style point-free
Omettre les arguments, plus concis
-- a type parameter 'a' (like Maybe)
data Maybe' a = Nothing' | Just' a
-- a boxed value
data Box a = Box a
-- use it with any type
> Just' 5
Just' 5
> Box "hello"
Box "hello"
-- model failure with Maybe
divide :: Double -> Double -> Maybe' Double
divide _ 0 = Nothing'
divide x y = Just' (x/y)Types récursifs
Un type peut se référencer lui-même, formant des structures récursives. IntList est une liste simplement chaînée d'Ints. Tree a est un arbre binaire. Le pattern matching récuse naturellement sur de telles structures.
-- a custom linked list
data IntList = INil | ICons Int IntList
-- build the list 1,2,3
xs = ICons 1 (ICons 2 (ICons 3 INil))
-- a binary tree
data Tree a = Leaf | Node a (Tree a) (Tree a)
tree = Node 1 (Node 2 Leaf Leaf) (Node 3 Leaf Leaf)Un BST avec fonctions
Les types algébriques de données s'accordent naturellement aux fonctions récursives via le pattern matching. Cette implémentation de BST insère en conservant l'ordre, et le parcours inorder s'aplatit en liste triée. Les ADT plus la récursion remplacent les classes en POO.
data Tree a = Leaf | Node a (Tree a) (Tree a)
-- insert into a binary search tree
insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node x Leaf Leaf
insert x (Node y l r)
| x < y = Node y (insert x l) r
| otherwise = Node y l (insert x r)
-- inorder traversal yields a sorted list
inorder :: Tree a -> [a]
inorder Leaf = []
inorder (Node x l r) = inorder l ++ [x] ++ inorder rÉnumérations
Un type somme de constructeurs nullaires agit comme un enum. Deriving Enum active succ/pred et la syntaxe de plage ([North ..]) ; deriving Bounded donne minBound/maxBound. C'est l'énumération idiomatique de Haskell.
-- enum-like sum type
data Direction = North | East | South | West
deriving (Eq, Ord, Enum, Bounded, Show)
-- enumerate via Enum
> [North .. West]
[North,East,South,West]
-- Bounded: the limits
> minBound :: Direction
North
> maxBound :: Direction
West
-- cycle through directions
next :: Direction -> Direction
next West = North
next d = succ dMonades
Monade Maybe
Maybe gère automatiquement la propagation des échecs
-- without records (positional, error-prone)
data Person0 = Person0 String Int String
-- with records (named fields)
data Person = Person
{ name :: String
, age :: Int
, city :: String
}
-- construct with field names (any order)
p1 = Person { name = "Alice", age = 30, city = "NYC" }Monade List
La monade List représente un calcul non déterministe
-- field names are accessor functions
> name p1
"Alice"
> age p1
30
-- their types
> :t name
name :: Person -> String
> :t age
age :: Person -> Int
-- record patterns also work
greet :: Person -> String
greet (Person { name = n }) = "Hi, " ++ nMonade IO
La monade IO isole les effets de bord
-- functional update: change only some fields
p2 = p1 { age = 31 }
-- the original is unchanged (immutable)
> age p1
30
> age p2
31
-- update multiple fields at once
p3 = p1 { age = 31, city = "LA" }Opérateur bind
>>= est l'opération centrale des monades
-- match and bind fields by name
birthday :: Person -> Person
birthday p@Person { age = a } = p { age = a + 1 }
-- ignore unneeded fields
getName :: Person -> String
getName Person { name = n } = n
-- as-pattern keeps the whole record
isAdult :: Person -> Bool
isAdult p@Person { age = a } = a >= 18return
return place une valeur dans un contexte de monade
-- field names share a top-level namespace
data Person = Person { name :: String }
data Company = Company { name :: String }
-- ERROR: 'name' clashes in the same module
-- workaround 1: prefix the fields
data Person' = Person' { personName :: String }
data Company' = Company' { companyName :: String }
-- workaround 2: language extensions
{-# LANGUAGE DuplicateRecordFields #-}Foncteurs
fmap
fmap applique une fonction à une valeur dans un foncteur
-- file Geometry.hs
module Geometry
( sphereVolume -- explicit export list
, cubeVolume
) where
sphereVolume :: Float -> Float
sphereVolume r = (4/3) * pi * r^3
cubeVolume :: Float -> Float
cubeVolume s = s^3
-- a helper not in the export list is private
privateHelper = ...Opérateur <$>
<$> est équivalent à fmap
-- import everything from Data.List
import Data.List
-- names are now in scope
> sort [3,1,2]
[1,2,3]
> nub [1,1,2,2,3]
[1,2,3]
-- import specific functions
import Data.Maybe (fromMaybe)
-- qualified: use the full module name
import qualified Data.Map as M
> M.emptyFoncteur de fonction
fmap sur les fonctions est .
-- import only specific names
import Data.List (sort, nub, group)
-- import everything except some
import Data.List hiding (head, tail)
-- import a type without its constructors
import Data.Tree (Tree, Node)
-- import constructors too
import Data.Tree (Tree(..))Imports qualifiés
Les imports qualifiés imposent le préfixe de module, prévenant les collisions (ex. le filter de Prelude vs celui de Data.Map). import qualified M as M est idiomatique. Utilisez qualified pour les modules aux noms très chevauchants.
-- avoid name clashes with qualified
import qualified Data.Map as Map
import qualified Data.Set as Set
m = Map.empty
s = Set.fromList [1,2,3]
-- Prelude's filter vs Data.Map's
> filter even [1..6]
[2,4,6]
> Map.filter (>2) (Map.fromList [(1,'a'),(3,'b')])
fromList [(3,'b')]Prelude
Prelude est l'import par défaut, fournissant les fonctions et types courants. Masquez des entrées pour éviter les collisions ou employer de meilleures alternatives (ex. foldl' de Data.List). Beaucoup de projets utilisent des preludes personnalisés.
-- Prelude is imported by default
-- provides: map, filter, length, (+), etc.
-- hide entries to avoid clashes
import Prelude hiding (head, tail, foldl)
-- use better alternatives
import Data.List (foldl') -- strict fold
-- common standard modules
import Data.List
import Data.Maybe
import Data.Char
import Data.EitherHiérarchie de modules
Les noms de modules sont hiérarchiques et reflètent la structure de répertoires : A.B.C vit dans A/B/C.hs. Un module peut ré-exporter un autre avec 'module M' dans sa liste d'exports, utile pour empaqueter une API publique.
-- hierarchical names mirror directories
-- module Data.Geometry.Sphere where
-- lives in: Data/Geometry/Sphere.hs
-- import nested modules
import Data.Geometry.Sphere
import Data.Geometry.Cube
-- re-export a whole module
module MyMod
( module Data.List -- re-export
, myFunc
) where
import Data.List
myFunc = sortApplicatifs
Opérateur <*>
<*> applique une fonction dans un foncteur
-- IO actions produce effects when run
greet :: IO ()
greet = do
putStrLn "What's your name?"
name <- getLine
putStrLn ("Hello, " ++ name)
-- run in GHCi
> greet
What's your name?
Alice
Hello, AliceApplication de fonction pure
pure place une valeur dans un applicatif
-- every program starts in main
main :: IO ()
main = putStrLn "Hello, World!"
-- combine actions with do
main = do
greet
putStrLn "Done."
-- command-line arguments
import System.Environment
main = do
args <- getArgs
print argsApplicatif List
List <*> est un produit cartésien
-- do is sugar for sequential actions
echo = do
s <- getLine
putStrLn s
-- desugars to bind (>>=)
echo' = getLine >>= putStrLn
-- 'let' needs no 'in' inside do
greet = do
let msg = "Hi!"
putStrLn msgFonctions d'entrée
getLine lit une ligne (sans saut de ligne), getChar un seul caractère, getContents lit paresseusement tout stdin. Utilisez '<-' pour lier les résultats. getContents est paresseux — parfait pour les pipelines en flux.
-- read a line (without the newline)
> line <- getLine
hello world
> line
"hello world"
-- read a single character
> c <- getChar
a> c
'a'
-- read all of stdin lazily
process = do
text <- getContents
putStr (map toUpper text)Fonctions de sortie
putStrLn et putStr écrivent une String sur stdout, avec/sans saut de ligne final. print équivaut à putStrLn . show, il ajoute donc des guillemets autour des chaînes. Choisissez selon le besoin de saut de ligne et si la valeur est une String.
-- with a trailing newline
putStrLn :: String -> IO ()
-- without a newline
putStr :: String -> IO ()
-- any Show-able value
print :: Show a => a -> IO ()
> putStrLn "hi" -- hi
> putStr "hi" -- hi (no newline)
> print 5 -- 5
> print "hi" -- "hi" (with quotes)IO de fichiers
readFile lit paresseusement, writeFile écrase, appendFile ajoute à la fin. Utilisez bracket pour garantir la fermeture des ressources en cas d'exception. Les fichiers s'adressent par FilePath (un alias de String).
-- read a whole file (lazy)
readFile :: FilePath -> IO String
-- write a file (overwrites)
writeFile :: FilePath -> String -> IO ()
-- append to a file
appendFile :: FilePath -> String -> IO ()
main = do
contents <- readFile "input.txt"
writeFile "output.txt" (map toUpper contents)
-- safe resource handling
import Control.Exception (bracket)IO
IO de base
Les opérations IO sont dans la monade IO
-- Functor: a context you can map over
class Functor f where
fmap :: (a -> b) -> f a -> f b
-- '<$>' is fmap as an operator
> fmap (+1) (Just 5)
Just 6
> (+1) <$> Just 5
Just 6
> (+1) <$> Nothing
Nothing
> map (+1) [1,2,3] -- map is fmap for lists
[2,3,4]Lecture/Écriture de fichiers
readFile/writeFile gèrent les fichiers
-- Applicative: functions inside a context
class Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
-- apply a wrapped function
> pure (+) <*> Just 3 <*> Just 4
Just 7
> Just (+1) <*> Just 5
Just 6
-- for lists, <*> is the Cartesian product
> [(+1), (*2)] <*> [1,2,3]
[2,3,4,2,4,6]putStr/putChar
Différentes fonctions de sortie
-- Monad: sequential, dependent computations
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b -- bind
-- bind chains dependent computations
> Just 3 >>= \x -> Just (x+1)
Just 4
> Nothing >>= \x -> Just (x+1)
Nothing
-- '>>' ignores the left result
> putStrLn "a" >> putStrLn "b"
a
bInteraction
getLine lit une ligne d'entrée
-- do notation
greet = do
name <- getLine
putStrLn ("Hi " ++ name)
-- desugars to bind
greet' = getLine >>= \name ->
putStrLn ("Hi " ++ name)
-- 'let' becomes a regular binding
compute = do
let x = 5
print (x * x)
-- desugars to:
compute' = let x = 5 in print (x*x)Chaîne de la monade Maybe
La monade Maybe court-circuite : dès qu'une étape renvoie Nothing, tout le calcul est Nothing sans travail supplémentaire. do masque la vérification manuelle de Nothing, rendant la propagation d'échec automatique et propre.
-- short-circuit on Nothing
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- chain with do (auto-propagates failure)
calc = do
a <- safeDiv 10 2
b <- safeDiv a 2
return (b + 1)
> calc
Just 3.5
-- any Nothing stops the whole chain
> safeDiv 10 0 >>= \a -> safeDiv a 2
NothingMonade List
La monade liste modélise le non-déterminisme : chaque bind explore toutes les possibilités, produisant le produit cartésien. do sur les listes équivaut aux compréhensions de listes. Cela unifie les styles compréhension et monadique.
-- list bind = non-deterministic computation
> [1,2] >>= \x -> [x, x*10]
[1,10,2,20]
-- do over lists == list comprehension
pairs = do
x <- [1,2]
y <- ['a','b']
return (x, y)
> pairs
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- equivalent comprehension
> [(x,y) | x <- [1,2], y <- ['a','b']]Notation do
do de base
la syntaxe do simplifie les opérations de monade
-- 'type' creates a synonym (not a new type)
type String = [Char]
type PhoneNumber = String
type Name = String
-- improves readability of signatures
printEntry :: Name -> PhoneNumber -> IO ()
printEntry name num = putStrLn (name ++ ": " ++ num)let dans do
let dans do n'a pas besoin de in
-- newtype: one constructor, one field, zero cost
newtype Dollars = Dollars Double
newtype Count = Count Int
-- pattern match or unwrap the field
addDollars :: Dollars -> Dollars -> Dollars
addDollars (Dollars a) (Dollars b) = Dollars (a + b)
-- distinct type: can't mix with raw Double
total :: Dollars
total = addDollars (Dollars 10) (Dollars 20)Désucrage do
do est du sucre syntaxique pour >>=
-- type: just a synonym (no new type, no safety)
type Score = Int
-- newtype: distinct type, zero cost, one field
newtype Score' = Score' Int
-- data: full ADT, runtime cost,
-- can have multiple constructors/fields
data Score'' = Score'' Int | Bonus Int
-- newtype is strict: exactly one
-- constructor and one field, but a distinct typenewtype pour de nouvelles instances
newtype permet d'attacher des instances de typeclass différentes au même type sous-jacent. Sum et Product enveloppent le même nombre mais ont des instances Monoid différentes (addition vs multiplication). Un pattern courant et puissant.
-- wrap to attach different typeclass instances
newtype Sum a = Sum { getSum :: a }
instance Num a => Monoid (Sum a) where
mempty = Sum 0
Sum a `mappend` Sum b = Sum (a + b)
newtype Product a = Product { getProduct :: a }
-- different Monoid: multiplication
-- same underlying type, different behavior
> getSum (Sum 3 <> Sum 4)
7
> getProduct (Product 3 <> Product 4)
12Synonymes paramétrés
Les synonymes de types peuvent prendre des paramètres, servant d'abstractions légères. AssocList k v est [(k,v)], rendant les signatures auto-documentées. Employez-les pour la clarté, mais rappelez-vous qu'ils ne sont que des alias sans sûreté de type.
-- type synonyms can take parameters
type AssocList k v = [(k, v)]
-- used in signatures (self-documenting)
lookup :: Eq k => k -> AssocList k v -> Maybe v
lookup _ [] = Nothing
lookup k ((k',v):rest)
| k == k' = Just v
| otherwise = lookup k rest
-- more examples
type Parser a = String -> Maybe (a, String)
type Matrix a = [[a]]Snippets Haskell associés
Copy-paste ready code for common tasks.
Types et Type Classes
Définir des types de données algébriques et des type classes.
Maybe et IO Monad
Maybe pour la sécurité, IO pour les effets de bord.
List Comprehensions et Paresse
Générer des listes avec comprehensions et exploiter la paresse.
Functor, Applicative, Monad Type Classes
Trois type classes abstraites core.
IO et Notation Do
Programmation avec effets de bord en Haskell.
Modules et Imports
Organiser le code avec modules et contrôler les exports.
Paresse et Strictness
Comprendre l'évaluation paresseuse et quand vous avez besoin de strictness.
Applicative Functor
Appliquer des fonctions en contexte, moins puissant que Monad.
Was this helpful?