Embed Size (px)
Citation preview
“Tout ce que vous aveztoujours voulu savoir sur la
programmation fonctionnelle**sans jamais oser le demander”
François Sarradin
Xebia ITArchitects
● "Bien pour la programmation concurrente" ● "Moins de bugs" ● To reduce cyclomatic complexity is far more important than to
reduce the number of LOCs. Incidentally FP gives a great help to lower both -- @mariofusco
● "Un autre point de vue sur son langage quotidien" ● "Ça retourne le cerveau, pour le bien !"
Programmation fonctionnelleCe qu'on en dit...
○ "Ellitiste" ○ "Difficile à apprendre" ○ "À ne pas mettre entre toutes les mains" ○ "Purement académique" ○ "Ça retourne le cerveau"
Programmation fonctionnelleCe qu'on en dit aussi...
OK, mais...
Qu'est-ce que laprogrammation fonctionnelle ?
Récursion
Fonction
Monade
Monoïde
Lazy evaluation
Tail recursion
Curryfication
Point freePattern matching
ProgrammationFonctionnelle
Combinateur de point fixe
Continuation
Closuremap/filter/fold/zip
Lambda calcul
Inférence de type
Catamorphisme
Type system
Functor
Ordre supérieur
Type algébrique
Transparence référentielle
Au programme...
● La base du style fonctionnel○ Histoire de la programmation fonctionnelle○ Récursion / Ordre supérieur / Déterminisme○ Optimisation
● Traitement de flux d'informations
○ Liste en programmation fonctionnelle○ Fonctions sur listes
● Conclusion
● Hands On
● Haskell (principalement) ● Scala, Clojure, Erlang, etc.
● Java + Guava (pour le Hands On)
Langages utilisés
Commençons
Soit la fonction factorielle
"n! est le produit des entiers compris entre 1 et n"
ou
n! = 1 * ⋯ * n = Πi i , ∀ i ∈ [1..n]
ou
0! = 1,n! = n . (n - 1)!, si n > 0.
StyleFonctionnel
int fact(int n): result = 1 for i in [1..n]: result = result * i return result
fact n = product [1..n](haskell)
Impératif
(defn fact [n] (reduce * 1 (range 1 (inc n))))
(clojure)
fact(0) -> 1;fact(N) -> N * fact(N - 1).
(erlang)
public int fact(int n) { if (n == 0) return 1; else return n * fact(n-1);}
(java)
Et aussi...
Point freeComposition de fonctions + disparition des variables ContinuationFutur de la fonction en paramètre Combinateur de point fixePermet les fonctions anonymes et récursives MonadeChaînage de traitements
Mais aussi des dérives...
factorial←{⍺←1⍵=0:⍺(⍺×⍵)∇ ⍵-1
}
life←{ ↑1 ⍵∨.^3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵ }
APL (A Programming Language)
Programmation fonctionnellePrincipe n°1 : tout est fonction
Tout est fonctionAu sens mathématique
f(x) = 2.x
x ↦ x + 42
h(x, y) = ∂2 p(x, y) / ∂x2
FonctionDans les langages fonctionnels
Haskellidentity x = x\x -> x
Scaladef identity(x: Any) = x{ x: Any => x }
Clojure(defn identity [x] x)(fn [x] x)
FonctionAvec Guava
new Function<T, R>() { @Override public R apply(T x) { return x; }} new Predicate<T>() { @Override public boolean apply(T x) { return x == null; }}
Programmation fonctionnelleD'où est-ce que ça vient ?
Fonction mathématiquefin du XVIIe siècle
f : x ↦ x f : x ↦ 2 . x
ou
f(x) = 2 . xGottfried Wilhelm von Leibniz(1646-1716)
λx.x(λx.2*x) 7 → 2 * 7 true ::= λxy.xfalse ::= λxy.yif-then-else ::= λpab.p a b 0 ::= λfx.x1 ::= λfx.f x2 ::= λfx.f (f x)
Lambda-calcul1936
Alonzo Church(1903-1995)
(lambda (x) x)(f arg1 arg2 ...)(lambda (x) (* 2 x)) (cons A B)(car (cons A B)) => A(cdr (cons A B)) => B
LISP1958
John McCarthy (1927-2011)
Et ensuite...
Lisp (1958) Scheme (1975) Common Lisp (1984) Clojure (2007)
APL (1964) FP (1977) J (1990)
ISWIM (1966) ML (1973) Caml (1985) F# (2002) Haskell (1987) Scala (2003)
Forth (1970s) PostScript (1982) RPL (1984) Joy (2001)
Prolog (1972) Erlang (1986)
Version "embarqué"
● Langage○ Java 8 (en 2012 ?)○ Groovy○ Python○ Ruby○ SmallTalk○ ...
● API Java
○ Guava○ LambdaJ○ TotallyLazy○ FunctionalJava○ FunkyJFunctional
Success stories
● Banque / finance○ Jane Street (OCaml)○ Goldman Sachs (Erlang), CitiGroup (Clojure), ...
● Réseaux sociaux○ Twitter (Scala)○ FourSquare (Scala/Lift)○ Facebook (Erlang)
● Télécommunication○ Ericsson (Erlang)
● Autres...○ Microsoft (F#)○ CouchDB, RabbitMQ (Erlang)
Programmation fonctionnellePrincipe n°2 : récursion
Récursion
Boucle = fonction qui s'appelle elle même fact n = if n == 0 then 1 else n * fact (n-1)
Proscrire ○for○while○repeat○ etc.
Verboten !
Stateful !
def fact(n):r = 1for i in [1..n]:
r *= ireturn n
Récursion terminale
L'appel récursif est la dernière instructionfact_t n k = if n == 0 then k else fact_t (n-1) (n*k) fact n = fact_t n 1
Récursion : pile d'appels
-> fact(5) -> fact(4) -> fact(3) -> fact(2) -> fact(1) -> fact(0) <- 1 <- 1 * 1 = 1 <- 2 * 1 = 2 <- 3 * 2 = 6 <- 4 * 6 = 24<- 5 * 24 = 120
fact n = if n == 0 then 1 else n * fact (n-1)
Récursion terminale : pile d'appels
-> fact_t 5 1 -> fact_t 4 5 -> fact_t 3 20 -> fact_t 2 60 -> fact_t 1 120 -> fact_t 0 120 <- 120 <- 120 ...<- 120
fact_t n k = if n == 0 then k else fact_t (n-1) (n*k)
Récursion : beware !
Programmation fonctionnellePrincipe n°3 : ordre supérieur
Fonction d'ordre supérieurFonction en paramètre
Dérivéederiv(f, x) = d f(x) / dt
Application d'une fonction sur chaque élément d'une collection (Java 8 ?)
Arrays.asList(1, 2, 3).map(x -> x * x)
Fonction d'ordre supérieurFonction en sortie
Additionneur (curryfier)add : x ↦ (y ↦ x + y)
add_one = add 1
add_one 2 => 3add_one 10 => 11
Fonction d'ordre supérieur... ou les deux
Compositionf ∘ g : x ↦ f(g(x))
● Généricité / Réutilisation du code● Extension du langage / DSL interne
// Scalanew Order to buy(100 sharesOf "IBM") maxUnitPrice 300 using premiumPricing
new Order to sell(200 bondsOf "Sun") maxUnitPrice 300 using { (qty, unit) => qty * unit - 500 }
Ordre supérieurApports
Programmation fonctionnellePrincipe n°4 : déterminisme
● Fonction = Opération déclarative○ Indépendante + sans état interne + déterministe
Une fonction retourne toujours la même valeur pourvu qu'on lui fournisse les mêmes paramètres => Un bon point pour la programmation concurrente !=> (+) de testabilité, (-) d'effet de bord
Indépendance / Déterminisme
f(x) = x + time() => NON !f(x, t) = x + t => OUI !
x = x + 1 => NON !y = x + 1 => OUI !
● Variable (fonctionnelle)
= variable (mathématique)= constante (impératif)= final (Java)
=> Encore un bon point pour la programmation concurrente !=> (-) d'effet de bord
Immuabilité
Programmation fonctionnelleDéterminisme => Optimisation
Optimisation des fonctions récursives terminales
def fact(n, k): if n == 0: return k return fact(n - 1, k * n)
devient
def fact(n, k): while not (n == 0): k = k * n n = n - 1 return k
OptimisationStyle trampoline
Transparence référentielleUne expression peut être remplacée par son résultat sans changer le comportement du programme MémoizationConserver en cache le résultat d'une fonction selon ses paramètres
Optimisation
Flot de contrôle non linéaireSi aucune dépendance ne les lient, 2 fonctions peuvent être appelées dans n'importe quel ordre Évaluation retardéeÈvaluation selon le besoin Garbage collector-- Since 1958 --
Optimisation
Inférence de typeDéterminer automatiquement le type d'une expression ou d'une fonction Pattern matchingAppliquer un traitement sur une valeur selon son "aspect"=> switch-case on steroid!
value match { // Scala case 1 => ... case "hello" => ... case x:Int => ... case Symbol(a, b) => ...}
Sucre syntaxique
Programmation fonctionnellePrincipe n°5 : liste
Liste de vide[]
Ajouter un élément en tête
1 : [] == [1]1 : [2, 3] == [1, 2, 3]1 : 2 : 3 : [] == [1, 2, 3]
Récupérer la tête
head [1, 2, 3] == 1 Récupérer la queue
tail [1, 2, 3] == [2, 3]
ListeOpérations de base (Haskell)
ListeFinie
Haskell[1,2,3,4,5] => [1, 2, 3, 4, 5][1..5] => [1, 2, 3, 4, 5]['a'..'z'] => "abcdefghijklmnopqrstuvwxyz" Scala(1 to 5) => Range(1, 2, 3, 4, 5)('a' to 'z') => NumericRange(a, b,[...], y, z) Clojure(range 1 5) => (1 2 3 4)
ListeVers l'infini et au delà !
Haskell[1..] => [1, 2, 3, 4, 5, ...tail [1..] => [2, 3, 4, 5, 6, ...take 3 [1..] => [1, 2, 3]take 3 (drop 5 [1..]) => [6, 7, 8] ScalaN/A Clojure(range 1) => (1 2 3 4 5 6 ...
Iterator<Integer> oneToFiveIterator = new AbstractIterator<Integer>() { private int i = 1; @Override protected Integer computeNext() { if (i > 5) return endOfData(); else return i++; } };// évaluation retardée selon Java !
Et en Java + GuavaÉmuler les listes : iterator
Iterable<Integer> oneToFive = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return oneToFiveIterator; } }; assertThat(oneToFive)
.containsExactly(1, 2, 3, 4, 5);
Et en Java + GuavaÉmuler les listes : iterable
Et en Java + GuavaListe infinie : suite de 1
Iterator<Integer> onesIterator = new AbstractIterator<Integer>() { @Override protected Integer computeNext() { return 1; }} Iterable<Integer> ones = new Iterable<Integer>() { @Override public Iterator<Integer> iterator() { return onesIterator; }}
Programmation fonctionnelleOpérations de traitement sur listes
mapApplique une transformation sur chaque élément d'une liste
=> Guava : transform(iterable, function)
Haskellmap (+1) [1..5] => [2, 3, 4, 5, 6]
filterConserve que les éléments satisfaisant un prédicat
=> Guava : filter(iterable, predicate)
Haskellfilter (> 3) [1..5] => [4, 5]
Fonction sur listemap et filter
Fonction sur listezip
zipFusionne deux listes
zipWith f [a1, ..., an] [b1, ..., bm] => [f(a1, b1), ..., f(an, bn)]si n < m HaskellzipWith (+) [1..5] [6..8] => [7, 9, 11]
=> Pas d'équivalent en Guava
foldAgrège les valeurs d'une liste (somme, produit, liste, ...)
foldl f a0 [b1, ..., bn]=>
a1 <- f(a0, b1)a2 <- f(a1, b2)...an-1<- f(an-2, bn-1)return f(an-1, bn)
=> Pas d'équivalent en Guava
Fonction sur listefold/reduce
Fonction sur listefold/reduce
Haskellfoldl (+) 0 [1..5] => 15 product l = foldl (*) 1 lfact n = product [1..n] = foldl (*) 1 [1..n] reverse l = foldl (flip (:)) [] lreverse [1..5] => [5, 4, 3, 2, 1]
En résuméLa programmation fonctionnelle, c'est...
Particularité
● Tout est fonction○ Fonction sur des valeurs (1er ordre)○ Fonction sur des fonctions (ordre supérieur)○ Indépendance / Déterminisme / Immuabilité
● Optimisations diverses
● Récursion ● Traitement sur liste
Et plus encore...
Avantages
● Généricité / réutilisation / modularité ● Meilleure testabilité / fiabilité
● Adapter à la programmation concurrente
● Concision
Écrire du code avec un langage fonctionnel
= écrire des spécifications formelles
Difficulté
● Une façon de penser différente
● Courbe d'apprentissage○ idiomes, patterns, best practices
● Longtemps enfermée dans la communauté scientifique ● Déclaratif
○ Pas de maîtrise du déroulement (plus qu'avec Java)○ Bonne connaissance du compilateur/VM
● Trop de concision tue la lisibilité
Littérature
● Miran Lipovača, Learn You a Haskell for Great Good! (LYAH). Avril 2011. http://learnyouahaskell.com/
● Bryan O'Sullivan, Don Stewart, and John Goerzen, Real World Haskell
(RWH). Novembre 2008. http://book.realworldhaskell.org/
Congrès et User Groups
● International Conference on Functional Programming (ICFP), http://www.icfpconference.org/
● Commercial Users of Functional Programming (CUFP), http://cufp.org/
● Scala Days● Clojure/conj
● Paris Scala User Group (soirée - 1/mois)● Clojure Paris User Group (coding dojo - 1/semaine)
Sites webs
● Haskell : http://haskell.org/○ API doc : http://haskell.org/ghc/docs/7.0-latest/html/libraries/index.
html○ Web console : http://tryhaskell.org/
● Scala : http://www.scala-lang.org/○ API doc : http://www.scala-lang.org/api/current/index.html#package○ Web console : http://www.simplyscala.com/
● Clojure : http://clojure.org/○ API doc : http://clojure.github.com/clojure/, http://clojuredocs.org/○ Web console : http://try-clojure.org/
