Programmation fonctionnelle

La programmation
fonctionnelle
En 45 minutes
Raphael Javaux

Plan
● Kesako ?
● Haskell
○ “An advanced purely-functional programming language”
● Stuff
● Real world stuff
● Aller plus loin

>>> xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> map(lambda x: x * x, xs)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
Kesako ?
λ ?

>>> xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> map(lambda x: x * x, xs)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
Kesako ?
λ ?
Pas vraiment ...

Kesako ?
« La programmation fonctionnelle est un style de
programmation qui met l'accent sur l'évaluation d’
expressions, plutôt que sur l'exécution de commandes. »
Graham Hutton

Kesako ?
Les programmes impératifs sont des séquences d’instructions
void estPair(int x)
{
if (x % 2 == 0)
printf("x est pair !n");
else
printf("x est impair !n");
}
Temps
Fais ça
puis ça
puis ça
...

Kesako ?
La programmation fonctionnelle retire cette notion de
temps.

“The world's most popular functional language”

Kesako ?
Comment ?
Une fonction ou une expression accepte des données en
entrée et en retourne de nouvelles.
Mais ne modifie aucun état global, ni aucun de ses
arguments.

Kesako ?
Comment ?
● Pas de modification des données
○ Pour modifier une donnée, on en crée une nouvelle
copie
● Pas d’effet de bord
○ Pas de modification de variables globales
○ Pas d’entrée/sortie

Kesako ?
struct rect_t {
int x, y, width, height;
}
void move(rect_t *rect, int dx, int dy)
{
rect->x += dx;
rect->y += dy;
}
struct rect_t {
int x, y, width, height;
}
rect_t move(rect_t rect, int dx, int dy)
{
return {
.x = rect.x + dx,
.y = rect.y + dy,
.width = rect.width,
.height = rect.height
};
}
Impératif Fonctionnel

Kesako ?
rect_t my_rectangle()
{
rect_t rect = {
.x = 0, .y = 0,
.width = 100, .height = 100
};
move(&rect, 10, 10);
return rect;
}
rect_t my_rectangle()
{
rect_t rect = {
.x = 0, .y = 0,
.width = 100, .height = 100
};
return move(rect, 10, 10);
}

Kesako ?
● Les fonctions sont :
○ déterministes
○ plus facilement testables
○ thread-safes
○ plus modulables
○ plus réutilisables
● Code plus facilement lisible
● Moins d’erreurs
● Optimisations
● Performances
○ Mais pas toujours ...
● Pas d’entrées/sorties
Avantages Désavantages

Récursion
?
int sum_n(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
sum += i;
return sum;
}
Modification de variable

Récursion
int sum_n(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
sum += i;
return sum;
}
int sum_n(int n)
{
if (n <= 0)
return 0;
else
return n + sum_n(n - 1);
}
int sum_n(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
sum += i;
return sum;
}
Modification de variable

Haskell - Syntaxe
-- Tous les opérateurs sont des fonctions
(+) :: Int -> Int -> Int
-- Les fonctions sont des valeurs
add :: Int -> Int -> Int
add = +
-- Une fonction a 2 arguments est une
-- fonction à 1 argument qui retourne
-- une fonction à 1 argument !
next :: Int -> Int
next = add 1
-- Ou directement
next = + 1
two = next 1 -- Equivalent à “add 1 1”
pi :: Double
pi = 3.1416
square :: Int -> Int
square x = x * x
-- Pas de parenthèse pour les appels de
-- fonctions
four :: Int
four = square 2
-- Pattern matching
isFive 5 = True
isFive x = False
-- Récursion
sumN n = if n <= 0 then 0
else n + sumN (n - 1)

Haskell - Listes
-- Liste vide
empty :: [Int]
empty = []
-- ":" permet d'ajouter un élément au
début de la liste
(:) :: Int -> [Int] -> [Int]
one :: [Int]
one = 1 : empty
xs :: [Int]
xs = 1 : 2 : 3 : 4 : 5 : []
-- Equivalent à :
xs = [ 1, 2, 3, 4, 5 ]
-- Pattern matching sur ":" et "[]"
length :: [Int] -> Int
length [] = 0
length (y : ys) = 1 + length ys
-- Concaténation de deux listes avec "++"
(++) :: [Int] -> [Int] -> [Int]
[] ++ zs = zs
(y : ys) ++ zs = y : (ys ++ zs)
-- Donne les premiers éléments d'une liste
take n [] = []
take 0 ys = []
take n (y : ys) = y : take (n - 1) ys
xs = : 1 2: 3: 4: 5: []

Stuff - Higher-order functions
-- Les fonctions peuvent elles-mêmes
-- recevoir des fonctions en argument :
map :: (Int -> Int) -> [Int] -> [Int]
map f [] = []
map f (x : xs) = f x : map f xs
filter :: (Int -> Bool) -> [Int] -> [Int]
filter p [] = []
filter p (x : xs) =
if p x then x : filter p xs
else filter p xs
>>> map square [ 1, 2, 3, 4, 5 ]
[ 1, 4, 9, 16, 25 ]
>>> filter (> 3) [ 10, 2, 3, 5, 0, 7 ]
[ 10, 5, 7 ]

Stuff - Quick Sort !
qsort [ 5, 2, 3, 10, 0, 7 ]
qsort [ 2, 3, 0 ] ++ [ 5 ] ++ qsort [ 7, 10 ]
qsort [ 0 ] ++ [ 2 ] ++ qsort [ 3 ] qsort [] ++ [ 7 ] ++ qsort [ 10 ]
[] ++ [ 0 ] ++ [] [] ++ [ 3 ] ++ [] [] ++ [ 10 ] ++ []

qsort [ 5, 2, 3, 10, 0, 7 ]
qsort [ 2, 3, 0 ] ++ [ 5 ] ++ qsort [ 7, 10 ]
[] ++ [ 0 ] ++ [] [] ++ [ 3 ] ++ [] [] ++ [ 10 ] ++ []
qsort :: [Int] -> [Int]
qsort [] = []
qsort (x : xs) = qsort lesser ++ [ x ] ++ qsort greater
where
lesser = filter (<= x) xs
greater = filter (> x) xs

>>> qsort oneMillion
5.05 secs

5.05 secs
>>> take 100 (qsort oneMillion)

Stuff - Haskell is lazy
5.05 secs
>>> take 100 (qsort oneMillion)
0.48 secs
WTF ?!!?

● Haskell est un langage à évaluation « paresseuse »
○ Une donnée calculée que lorsqu’elle est accèdée pour
la première fois
● Chaque noeud d’une liste est une donnée : 1 2: []

take 3 (qsort [ 5, 2, 3, 10, 0, 7 ])
qsort [ 2, 3, 0 ] ++ [ 5 ] ++ qsort [ 7, 10 ]
[] ++ [ 0 ] ++ [] [] ++ [ 3 ] ++ [] [] ++ [ 10 ] ++ []
● Haskell est un langage à évaluation « paresseuse »
○ Une donnée calculée que lorsqu’elle est accèdée pour
la première fois
● Chaque noeud d’une liste est une donnée : 1 2: []

Real world stuff - Entrées sorties
IO
Fonctionnel

Real world stuff - Entrées et sorties
-- Les fonctions ayant des effets de bords retournent “ IO a ”,
-- où “ a ” est la valeur retournée.
-- “ () ” est l'équivalent de “ void ”.
putStrLn :: Text -> IO ()
readFile :: FilePath -> IO Text
writeFile :: FilePath -> Text -> IO ()
getArgs :: IO [Text]

Real world stuff - Entrées et sorties
-- “ do ” permet de séquencer des fonctions à effets de bord
-- comme dans un langage impératif.
-- “ <- ” permet de récupérer le résutat d’une “ IO ”.
main :: IO ()
main = do
[ path ] <- getArgs
c <- readFile path
putStrLn c

Real world stuff - Grep
$ grep "Maître" le_corbeau_et_le_renard.txt
Maître Corbeau, sur un arbre perché,
Maître Renard, par l’odeur alléché,

lines :: Text -> [Text]
unlines :: [Text] -> Text
isInfixOf :: Text -> Text -> Bool
grep :: Text -> Text -> Text
grep pattern text = unlines matches
where
ls = lines text
matches = filter (isInfixOf pattern) ls
main = do
[pattern, path] <- getArgs
text <- readFile path
putStrLn (grep pattern text)

$ du -h de_bello_gallico.txt
144K de_bello_gallico.txt
$ grep "Belg" de_bello_gallico.txt
[ 26 lignes ... ]
0.003 secs (1 868 870 cycles CPU)
$ ./GrepHS "Belg" de_bello_gallico.txt
[ 26 lignes ... ]
0.008 secs (6 603 153 cycles CPU, GC : 1.4%) - Mem. max. : 1 MB

$ du -h de_bello_gallico_large.txt
141M de_bello_gallico_large.txt
$ grep "Belg" de_bello_gallico_large.txt
[ 26 000 lignes ... ]
0.0988 secs (326 516 484 cycles CPU)
$ ./GrepHS "Belg" de_bello_gallico_large.txt
[ 26 000 lignes ... ]
1.632 secs (5 973 858 671 cycles CPU, GC : 0.5 %) - Mem. max. : 1 MB

Real world stuff - Haskell lazy again !
$ du -h de_bello_gallico_large.txt
141M de_bello_gallico_large.txt
$ grep "Belg" de_bello_gallico_large.txt
[ 26 000 lignes ... ]
0.0988 secs (326 516 484 cycles CPU)
$ ./GrepHS "Belg" de_bello_gallico_large.txt
[ 26 000 lignes ... ]
1.632 secs (5 973 858 671 cycles CPU, GC : 0.5 %) - Mem. max. : 1 MB
WTF ?!!??
text <- readFile path
putStrLn (grep pattern text)

Real world stuff - Haskell lazy again !
text =
[]
: alléchénLui tint à peu près ce langage :n"Hé ! bonjour, Monsieur du Corbeau.nQue vous êtes joli
: êtes le Phenix des hôtes de ces bois.nÀ ces mots le Corbeau ne se sent pas de joie :nEt pour montrer
: ! que vous me semblez beau !nSans mentir, si votre ramagenSe rapporte à votre plumage,nVous
: sa belle voix,nIl ouvre un large bec, laisse tomber sa proie.nLe Renard s’en saisit, et dit : Mon bon
: un fromage sans doute.nLe Corbeau honteux et confusnJura, qu’on ne l’y prendrait plus.
: Monsieur,nApprenez que tout flatteurnVit aux dépens de celui qui l’écoute.nCette leçon vaut bien
Maître Corbeau sur un arbre perché,nTenait en son bec un fromage.nMaître Renard par l’odeur:

Aller plus loin - Pourquoi ?
● Programmer ...
○ … plus modulable
○ … plus réutilisable
○ … plus rigoureusement
● Monstrueusement efficace pour ...
○ … la programmation parallèle et concurrente
○ … le backend et les réseaux
● De plus en plus de langages tendent vers le paradigme

Aller plus loin - Langages
Fonctionnel
O
rienté
objet
Im
pératif
LISPs

Aller plus loin - Langages
Fonctionnel
O
rienté
objet
Im
pératif
LISPs
Microsoft .NET
Java VM
Réseaux et haute
disponibilité
Très bas niveau

Moyenne sur 13 benchmarks
Source : http://benchmarksgame.alioth.debian.org/u64q/which-programs-are-fastest.html

Benchmark des context-switchs.
Source : http://benchmarksgame.alioth.debian.org/u64q/performance.php?test=threadring

Programmation fonctionnelle

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Programmation fonctionnelle

Similaire à Programmation fonctionnelle (20)

Plus de Geeks Anonymes

Plus de Geeks Anonymes (20)

Programmation fonctionnelle