895 lines
24 KiB
Org Mode
895 lines
24 KiB
Org Mode
#+Title: Introduction à la Programmation Fonctionnelle avec Haskell
|
||
#+Author: Yann Esposito
|
||
#+Email: yann@esposito.host
|
||
#+Date: <2018-03-15 Thu>
|
||
#+LANGUAGE: fr
|
||
#+LANG: fr
|
||
#+HTML_HEAD: <link rel='stylesheet' type='text/css' href='/css/slides.css' />
|
||
* Introduction à la Programmation Fonctionnelle avec Haskell
|
||
*** main :: IO ()
|
||
|
||
#+BEGIN_SRC
|
||
████████████████████████████████████████████████████████████████████████████████████
|
||
█ █
|
||
█ Initialiser l'env de dev █
|
||
█ █
|
||
████████████████████████████████████████████████████████████████████████████████████
|
||
#+END_SRC
|
||
|
||
Install **stack**:
|
||
|
||
#+BEGIN_SRC bash
|
||
curl -sSL https://get.haskellstack.org/ | sh
|
||
#+END_SRC
|
||
|
||
Install **nix**:
|
||
|
||
#+BEGIN_SRC bash
|
||
curl https://nixos.org/nix/install | sh
|
||
#+END_SRC
|
||
|
||
** Programmation Fonctionnelle?
|
||
*** Von Neumann Architecture (1945)
|
||
|
||
#+BEGIN_SRC
|
||
+--------------------------------+
|
||
| +----------------------------+ |
|
||
| | central processing unit | |
|
||
| | +------------------------+ | |
|
||
| | | Control Unit | | |
|
||
+------+ | | +------------------------+ | | +--------+
|
||
|input +---> | +------------------------+ | +--> output |
|
||
+------+ | | | Arithmetic/Logic Unit | | | +--------+
|
||
| | +------------------------+ | |
|
||
| +-------+---^----------------+ |
|
||
| | | |
|
||
| +-------v---+----------------+ |
|
||
| | Memory Unit | |
|
||
| +----------------------------+ |
|
||
+--------------------------------+
|
||
#+END_SRC
|
||
|
||
made with http://asciiflow.com
|
||
|
||
*** Von Neumann vs Church
|
||
|
||
- programmer à partir de la machine (Von Neumann)
|
||
+ tire vers l'optimisation
|
||
+ mots de bits, caches, détails de bas niveau
|
||
+ actions séquentielles
|
||
+ *1 siècle d'expérience*
|
||
|
||
. . .
|
||
|
||
- programmer comme manipulation de symbole (Alonzo Church)
|
||
+ tire vers l'abstraction
|
||
+ plus proche des représentations mathématiques
|
||
+ ordre d'évaluation non imposé
|
||
+ *4000 ans d'expérience*
|
||
|
||
*** Histoire
|
||
|
||
- λ-Calculus, Alonzo Church & Rosser 1936
|
||
- Foundation, explicit side effect no implicit state
|
||
|
||
. . .
|
||
|
||
- LISP (McCarthy 1960)
|
||
- Garbage collection, higher order functions, dynamic typing
|
||
|
||
. . .
|
||
|
||
- ML (1969-80)
|
||
- Static typing, Algebraic Datatypes, Pattern matching
|
||
|
||
. . .
|
||
|
||
- Miranda (1986) → Haskell (1992‥)
|
||
- Lazy evaluation, pure
|
||
|
||
** Pourquoi Haskell?
|
||
*** Simplicité par l'abstraction
|
||
|
||
*=/!\= SIMPLICITÉ ≠ FACILITÉ =/!\=*
|
||
|
||
- mémoire (garbage collection)
|
||
- ordre d'évaluation (non strict / lazy)
|
||
- effets de bords (pur)
|
||
- manipulation de code (referential transparency)
|
||
|
||
. . .
|
||
|
||
Simplicité: Probablement le meilleur indicateur de réussite de projet.
|
||
|
||
*** Production Ready™
|
||
|
||
- rapide
|
||
- équivalent à Java (~ x2 du C)
|
||
- parfois plus rapide que C
|
||
- bien plus rapide que python et ruby
|
||
. . .
|
||
- communauté solide
|
||
- 3k comptes sur Haskellers
|
||
- >30k sur reddit /(35k rust, 45k go, 50k nodejs, 4k ocaml, 13k clojure)/
|
||
- libs >12k sur hackage
|
||
. . .
|
||
- entreprises
|
||
- Facebook (fighting spam, HAXL, ...)
|
||
- beaucoup de startups, finance en général
|
||
. . .
|
||
- milieu académique
|
||
- fondations mathématiques
|
||
- fortes influences des chercheurs
|
||
- tire le langage vers le haut
|
||
|
||
*** Tooling
|
||
|
||
- compilateur (GHC)
|
||
- gestion de projets ; cabal, stack, hpack, etc...
|
||
- IDE / hlint ; rapidité des erreurs en cours de frappe
|
||
- frameworks hors catégorie (servant, yesod)
|
||
- ecosystèmes très matures et inovant
|
||
- Elm (⇒ frontend)
|
||
- Purescript (⇒ frontend)
|
||
- GHCJS (⇒ frontend)
|
||
- Idris (types dépendants)
|
||
- Hackett (typed LISP avec macros)
|
||
- Eta (⇒ JVM)
|
||
|
||
*** Qualité
|
||
|
||
#+BEGIN_QUOTE
|
||
/Si ça compile alors il probable que ça marche/
|
||
#+END_QUOTE
|
||
. . .
|
||
- tests unitaires :
|
||
chercher quelques erreurs manuellements
|
||
. . .
|
||
- /test génératifs/ :
|
||
chercher des erreurs sur beaucoups de cas générés aléatoirements
|
||
& aide pour trouver l'erreur sur l'objet le plus simple
|
||
. . .
|
||
- /finite state machine generative testing/ :
|
||
chercher des erreurs sur le déroulement des actions
|
||
entre différents agents indépendants
|
||
. . .
|
||
- *preuves*:
|
||
chercher des erreur sur *TOUTES* les entrées possibles
|
||
possible à l'aide du système de typage
|
||
|
||
* Premiers Pas en Haskell
|
||
*** DON'T PANIC
|
||
|
||
#+BEGIN_SRC
|
||
██████╗ ██████╗ ███╗ ██╗████████╗ ██████╗ █████╗ ███╗ ██╗██╗ ██████╗██╗
|
||
██╔══██╗██╔═══██╗████╗ ██║╚══██╔══╝ ██╔══██╗██╔══██╗████╗ ██║██║██╔════╝██║
|
||
██║ ██║██║ ██║██╔██╗ ██║ ██║ ██████╔╝███████║██╔██╗ ██║██║██║ ██║
|
||
██║ ██║██║ ██║██║╚██╗██║ ██║ ██╔═══╝ ██╔══██║██║╚██╗██║██║██║ ╚═╝
|
||
██████╔╝╚██████╔╝██║ ╚████║ ██║ ██║ ██║ ██║██║ ╚████║██║╚██████╗██╗
|
||
╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═════╝╚═╝
|
||
#+END_SRC
|
||
|
||
- Haskell peut être difficile à vraiment maîtriser
|
||
- Trois languages en un:
|
||
- Fonctionnel
|
||
- Imperatif
|
||
- Types
|
||
- Polymorphisme:
|
||
- contexte souvent semi-implicite change le comportement du code.
|
||
|
||
*** Fichier de script isolé
|
||
|
||
Avec Stack: https://haskellstack.org
|
||
|
||
#+BEGIN_SRC haskell
|
||
#!/usr/bin/env stack
|
||
{- stack script
|
||
--resolver lts-12.10
|
||
--install-ghc
|
||
--package protolude
|
||
-}
|
||
#+END_SRC
|
||
|
||
Avec Nix: https://nixos.org/nix/
|
||
|
||
#+BEGIN_SRC shell
|
||
#! /usr/bin/env nix-shell
|
||
#! nix-shell -i runghc
|
||
#! nix-shell -p "ghc.withPackages (ps: [ ps.protolude ])"
|
||
#! nix-shell -I nixpkgs="https://github.com/NixOS/nixpkgs/archive/18.09.tar.gz"
|
||
#+END_SRC
|
||
|
||
*** Hello World! (1/3)
|
||
|
||
#+BEGIN_SRC haskell
|
||
-- hello.hs
|
||
main :: IO ()
|
||
main = putStrLn "Hello World!"
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC
|
||
> chmod +x hello.hs
|
||
> ./hello.hs
|
||
Hello World!
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC
|
||
> stack ghc -- hello.hs
|
||
> ./hello
|
||
Hello World!
|
||
#+END_SRC
|
||
|
||
*** Hello World! (2/3)
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = putStrLn "Hello World!"
|
||
#+END_SRC
|
||
|
||
- ~::~ de type ;
|
||
- le type de ~main~ est ~IO ()~.
|
||
- ~=~ égalité (la vrai, on peut interchanger ce qu'il y a des deux cotés) ;
|
||
- le type de ~putStrLn~ est ~String -> IO ()~ ;
|
||
- application de fonction =f x= pas =f(x)=, pas de parenthèse nécessaire ;
|
||
|
||
*** Hello World! (3/3)
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = putStrLn "Hello World!"
|
||
#+END_SRC
|
||
|
||
- Le type ~IO a~ signifie: C'est une description d'une procédure qui quand elle
|
||
est évaluée peut faire des actions d'IO qui retournera une valeur de type ~a~ ;
|
||
- ~main~ est le nom du point d'entrée du programme ;
|
||
- Haskell runtime va chercher pour ~main~ et l'exécute.
|
||
|
||
** What is your name?
|
||
*** What is your name? (1/2)
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = do
|
||
putStrLn "Hello! What is your name?"
|
||
name <- getLine
|
||
let output = "Nice to meet you, " ++ name ++ "!"
|
||
putStrLn output
|
||
#+END_SRC
|
||
|
||
. . .
|
||
|
||
- l'indentation est importante !
|
||
- ~do~ commence une syntaxe spéciale qui permet de séquencer des actions ~IO~ ;
|
||
- le type de ~getLine~ est ~IO String~ ;
|
||
- ~IO String~ signifie: Ceci est la description d'une procédure qui lorsqu'elle
|
||
est évaluée peut faire des actions IO et retourne une valeur de type ~String~.
|
||
|
||
*** What is your name? (2/2)
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = do
|
||
putStrLn "Hello! What is your name?"
|
||
name <- getLine
|
||
let output = "Nice to meet you, " ++ name ++ "!"
|
||
putStrLn output
|
||
#+END_SRC
|
||
|
||
- le type de ~getLine~ est ~IO String~
|
||
- le type de ~name~ est ~String~
|
||
- ~<-~ est une syntaxe spéciale qui n'apparait que dans la notation ~do~
|
||
- ~<-~ signifie: évalue la procédure et attache la valeur renvoyée dans le nom
|
||
à gauche de ~<-~
|
||
- ~let <name> = <expr>~ signifie que ~name~ est interchangeable avec ~expr~ pour
|
||
le reste du bloc ~do~.
|
||
- dans un bloc ~do~, ~let~ n'a pas besoin d'être accompagné par ~in~ à la fin.
|
||
|
||
** Erreurs classiques
|
||
*** Erreur classique #1
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = do
|
||
putStrLn "Hello! What is your name?"
|
||
let output = "Nice to meet you, " ++ getLine ++ "!"
|
||
putStrLn output
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC
|
||
/Users/yaesposi/.deft/pres-haskell/name.hs:6:40: warning: [-Wdeferred-type-errors]
|
||
• Couldn't match expected type ‘[Char]’
|
||
with actual type ‘IO String’
|
||
• In the first argument of ‘(++)’, namely ‘getLine’
|
||
In the second argument of ‘(++)’, namely ‘getLine ++ "!"’
|
||
In the expression: "Nice to meet you, " ++ getLine ++ "!"
|
||
|
|
||
6 | let output = "Nice to meet you, " ++ getLine ++ "!"
|
||
| ^^^^^^^
|
||
Ok, one module loaded.
|
||
#+END_SRC
|
||
|
||
*** Erreur classique #1
|
||
|
||
- ~String~ est ~[Char]~
|
||
- Haskell n'arrive pas à faire matcher le type ~String~ avec ~IO String~.
|
||
- ~IO a~ et ~a~ sont différents
|
||
|
||
*** Erreur classique #2
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = do
|
||
putStrLn "Hello! What is your name?"
|
||
name <- getLine
|
||
putStrLn "Nice to meet you, " ++ name ++ "!"
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC
|
||
/Users/yaesposi/.deft/pres-haskell/name.hs:7:3: warning: [-Wdeferred-type-errors]
|
||
• Couldn't match expected type ‘[Char]’ with actual type ‘IO ()’
|
||
• In the first argument of ‘(++)’, namely
|
||
‘putStrLn "Nice to meet you, "’
|
||
In a stmt of a 'do' block:
|
||
putStrLn "Nice to meet you, " ++ name ++ "!"
|
||
In the expression:
|
||
do putStrLn "Hello! What is your name?"
|
||
name <- getLine
|
||
putStrLn "Nice to meet you, " ++ name ++ "!"
|
||
|
|
||
7 | putStrLn "Nice to meet you, " ++ name ++ "!"
|
||
#+END_SRC
|
||
|
||
*** Erreur classique #2 (fix)
|
||
|
||
- Des parenthèses sont nécessaires
|
||
- L'application de fonction se fait de gauche à droite
|
||
|
||
#+BEGIN_SRC haskell
|
||
main :: IO ()
|
||
main = do
|
||
putStrLn "Hello! What is your name?"
|
||
name <- getLine
|
||
putStrLn ("Nice to meet you, " ++ name ++ "!")
|
||
#+END_SRC
|
||
|
||
* Concepts avec exemples
|
||
*** Concepts
|
||
- /style déclaratif & récursif/
|
||
- /immutabilité/
|
||
- /pureté/ (par défaut)
|
||
- /evaluation paraisseuse/ (par défaut)
|
||
- /ADT & typage polymorphique/
|
||
|
||
*** /Style déclaratif & récursif/
|
||
|
||
#+BEGIN_SRC python
|
||
>>> x=0
|
||
... for i in range(1,11):
|
||
... tmp = i*i
|
||
... if tmp%2 == 0:
|
||
... x += tmp
|
||
>>> x
|
||
220
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC haskell
|
||
-- (.) composition (de droite à gauche)
|
||
Prelude> sum . filter even . map (^2) $ [1..10]
|
||
220
|
||
Prelude> :set -XNoImplicitPrelude
|
||
Prelude> import Protolude
|
||
-- (&) flipped fn application (de gauche à droite)
|
||
Protolude> [1..10] & map (^2) & filter even & sum
|
||
220
|
||
#+END_SRC
|
||
|
||
*** /Style déclaratif & récursif/
|
||
|
||
#+BEGIN_SRC python
|
||
>>> x=0
|
||
... for i in range(1,11):
|
||
... j = i*3
|
||
... tmp = j*j
|
||
... if tmp%2 == 0:
|
||
... x += tmp
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC haskell
|
||
Prelude> sum . filter even . map (^2) . map (*3) $ [1..10]
|
||
Protolude> [1..10] & map (*3) & map (^2) & filter even & sum
|
||
#+END_SRC
|
||
|
||
*** /Style déclaratif & récursif/
|
||
|
||
- Contrairement aux languages impératifs la récursion n'est généralement pas chère.
|
||
- tail recursive function, mais aussi à l'aide de la lazyness
|
||
|
||
*** /Imutabilité/
|
||
|
||
#+BEGIN_SRC haskell
|
||
-- | explicit recursivity
|
||
incrementAllEvenNumbers :: [Int] -> [Int]
|
||
incrementAllEvenNumbers (x:xs) = y:incrementAllEvenNumbers xs
|
||
where y = if even x then x+1 else x
|
||
|
||
-- | better with use of higher order functions
|
||
incrementAllEvenNumbers' :: [Int] -> [Int]
|
||
incrementAllEvenNumbers' ls = map incrementIfEven ls
|
||
where
|
||
incrementIfEven :: Int -> Int
|
||
incrementIfEven x = if even x then x+1 else x
|
||
#+END_SRC
|
||
|
||
*** /Pureté/: Function vs Procedure/Subroutines
|
||
|
||
- Une /fonction/ n'a pas d'effet de bord
|
||
- Une /Procedure/ ou /subroutine/ but engendrer des effets de bords lors de son
|
||
évaluation
|
||
|
||
*** /Pureté/: Function vs Procedure/Subroutines (exemple)
|
||
|
||
#+BEGIN_SRC haskell
|
||
dist :: Double -> Double -> Double
|
||
dist x y = sqrt (x**2 + y**2)
|
||
#+END_SRC
|
||
|
||
|
||
#+BEGIN_SRC haskell
|
||
getName :: IO String
|
||
getName = readLine
|
||
#+END_SRC
|
||
|
||
- *IO a* ⇒ *IMPUR* ; effets de bords hors evaluation :
|
||
- lire un fichier ;
|
||
- écrire sur le terminal ;
|
||
- changer la valeur d'une variable en RAM est impur.
|
||
|
||
*** /Pureté/: Gain, paralellisation gratuite
|
||
|
||
#+BEGIN_SRC haskell
|
||
import Foreign.Lib (f)
|
||
-- f :: Int -> Int
|
||
-- f = ???
|
||
|
||
foo = sum results
|
||
where results = map f [1..100]
|
||
#+END_SRC
|
||
|
||
. . .
|
||
*~pmap~ FTW!!!!! Assurance d'avoir le même résultat avec 32 cœurs*
|
||
|
||
#+BEGIN_SRC haskell
|
||
import Foreign.Lib (f)
|
||
-- f :: Int -> Int
|
||
-- f = ???
|
||
|
||
foo = sum results
|
||
where results = pmap f [1..100]
|
||
#+END_SRC
|
||
|
||
*** /Pureté/: Structures de données immuable
|
||
|
||
Purely functional data structures,
|
||
/Chris Okasaki/
|
||
|
||
Thèse en 1996, et un livre.
|
||
|
||
Opérations sur les listes, tableaux, arbres
|
||
de complexité amortie equivalent ou proche
|
||
(pire des cas facteur log(n))
|
||
de celle des structures de données muables.
|
||
|
||
*** /Évaluation parraisseuse/: Stratégies d'évaluations
|
||
=(h (f a) (g b))= peut s'évaluer:
|
||
|
||
- =a= → =(f a)= → =b= → =(g b)= → =(h (f a) (g b))=
|
||
- =b= → =a= → =(g b)= → =(f a)= → =(h (f a) (g b))=
|
||
- =a= et =b= en parallèle puis =(f a)= et =(g b)= en parallèle et finallement =(h (f a) (g b))=
|
||
- =h= → =(f a)= seulement si nécessaire et puis =(g b)= seulement si nécessaire
|
||
|
||
Par exemple: =(def h (λx.λy.(+ x x)))= il n'est pas nécessaire d'évaluer =y=,
|
||
dans notre cas =(g b)=
|
||
|
||
*** /Évaluation parraisseuse/: Exemple
|
||
|
||
#+BEGIN_SRC haskell
|
||
quickSort [] = []
|
||
quickSort (x:xs) = quickSort (filter (<x) xs)
|
||
++ [x]
|
||
++ quickSort (filter (>=x) xs)
|
||
|
||
minimum list = head (quickSort list)
|
||
#+END_SRC
|
||
|
||
Un appel à ~minimum longList~ ne vas pas ordonner toute la liste.
|
||
Le travail s'arrêtera dès que le premier élément de la liste ordonnée sera trouvé.
|
||
~take k (quickSort list)~ est en ~O(n + k log k)~ où ~n = length list~.
|
||
Alors qu'avec une évaluation stricte: ~O(n log n)~.
|
||
|
||
*** /Évaluation parraisseuse/: Structures de données infinies (zip)
|
||
|
||
#+BEGIN_SRC haskell
|
||
zip :: [a] -> [b] -> [(a,b)]
|
||
zip [] _ = []
|
||
zip _ [] = []
|
||
zip (x:xs) (y:ys) = (x,y):zip xs ys
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC haskell
|
||
zip [1..] ['a','b','c']
|
||
#+END_SRC
|
||
|
||
s'arrête et renvoie :
|
||
|
||
#+BEGIN_SRC haskell
|
||
[(1,'a'), (2,'b'), (3, 'c')]
|
||
#+END_SRC
|
||
|
||
*** /Évaluation parraisseuse/: Structures de données infinies (2)
|
||
|
||
#+BEGIN_SRC haskell
|
||
Prelude> zipWith (+) [0,1,2,3] [10,100,1000]
|
||
[10,101,1002]
|
||
Prelude> take 3 [1,2,3,4,5,6,7,8,9]
|
||
[1,2,3]
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC haskell
|
||
Prelude> fib = 0:1:(zipWith (+) fib (tail fib))
|
||
Prelude> take 10 fib
|
||
[0,1,1,2,3,5,8,13,21,34]
|
||
#+END_SRC
|
||
|
||
*** /ADT & Typage polymorphique/
|
||
|
||
Algebraic Data Types.
|
||
|
||
#+BEGIN_SRC haskell
|
||
data Void = Void Void -- 0 valeur possible!
|
||
data Unit = () -- 1 seule valeur possible
|
||
|
||
data Product x y = P x y
|
||
data Sum x y = S1 x | S2 y
|
||
#+END_SRC
|
||
|
||
Soit ~#x~ le nombre de valeurs possibles pour le type ~x~
|
||
alors:
|
||
|
||
- ~#(Product x y) = #x * #y~
|
||
- ~#(Sum x y) = #x + #y~
|
||
|
||
*** /ADT & Typage polymorphique/: Inférence de type
|
||
|
||
À partir de :
|
||
|
||
#+BEGIN_SRC haskell
|
||
zip [] _ = []
|
||
zip _ [] = []
|
||
zip (x:xs) (y:ys) = (x,y):zip xs ys
|
||
#+END_SRC
|
||
|
||
le compilateur peut déduire:
|
||
|
||
#+BEGIN_SRC haskell
|
||
zip :: [a] -> [b] -> [(a,b)]
|
||
#+END_SRC
|
||
|
||
** Composabilité
|
||
*** Composabilité vs Modularité
|
||
|
||
Modularité: soit un ~a~ et un ~b~, je peux faire un ~c~.
|
||
ex: x un graphique, y une barre de menu => une page ~let page = mkPage ( graphique, menu )~
|
||
|
||
Composabilité: soit deux ~a~ je peux faire un autre ~a~.
|
||
ex: x un widget, y un widget => un widget ~let page = x <+> y~
|
||
|
||
Gain d'abstraction, moindre coût.
|
||
*Hypothèses fortes sur les ~a~*
|
||
|
||
*** Exemples
|
||
|
||
- *Semi-groupes* 〈+〉
|
||
- *Monoides* 〈0,+〉
|
||
|
||
- *Catégories* 〈obj(C),hom(C),∘〉
|
||
- Foncteurs ~fmap~ (~(<$>)~)
|
||
- Foncteurs Applicatifs ~ap~ (~(<*>)~)
|
||
- Monades ~join~
|
||
- Traversables ~map~
|
||
- Foldables ~reduce~
|
||
|
||
* Catégories de bugs évités avec Haskell
|
||
|
||
*** Real Productions Bugs™
|
||
|
||
Bug vu des dizaines de fois en prod malgré:
|
||
|
||
1. specifications fonctionnelles
|
||
2. spécifications techniques
|
||
3. tests unitaires
|
||
4. 3 envs, dev, recette/staging/pre-prod, prod
|
||
5. Équipe de QA qui teste en recette
|
||
|
||
Solutions simples.
|
||
|
||
*** **Null Pointer Exception**: Erreur classique (1)
|
||
|
||
Au début du projet :
|
||
|
||
#+BEGIN_SRC javascript
|
||
int foo( x ) {
|
||
return x + 1;
|
||
}
|
||
#+END_SRC
|
||
|
||
*** **Null Pointer Exception**: Erreur classique (2)
|
||
|
||
Après quelques semaines/mois/années :
|
||
|
||
#+BEGIN_SRC javascript
|
||
import do_shit_1 from "foreign-module";
|
||
int foo( x ) {
|
||
...
|
||
var y = do_shit_1(x);
|
||
...
|
||
return do_shit_20(y)
|
||
}
|
||
...
|
||
var val = foo(26/2334 - Math.sqrt(2));
|
||
#+END_SRC
|
||
|
||
. . .
|
||
|
||
#+BEGIN_SRC
|
||
███████ █████ ███ ███ ███ ███ ███ ███ ███ ███ ███
|
||
███ ██ ███ ███ ███ ███ ████ ████ ███ ███ ███ ███ ███
|
||
███ ██ ███ ███ ███ ███ █████ █████ ███ ███ ███ ███ ███
|
||
███████ ███ ███ ███ ███ ███ █████ ███ ███ ███ ███ ███ ███
|
||
███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███
|
||
███ ███ ███ ███ ███ ███ ███ █ ███ █ █ █ █ █
|
||
███ ███ ███ ███ ███ ███ ███ ███
|
||
███████ █████ █████ ███ ███ ███ ███ ███ ███ ███
|
||
#+END_SRC
|
||
|
||
| *Null Pointer Exception*
|
||
|
||
*** Null Pointer Exception: Data type ~Maybe~
|
||
|
||
#+BEGIN_SRC haskell
|
||
data Maybe a = Just a | Nothing
|
||
...
|
||
foo :: Maybe a
|
||
...
|
||
myFunc x = let t = foo x in
|
||
case t of
|
||
Just someValue -> doThingsWith someValue
|
||
Nothing -> doThingWhenNothingIsReturned
|
||
#+END_SRC
|
||
|
||
Le compilateur oblige à tenir compte des cas particuliers!
|
||
Impossible d'oublier.
|
||
|
||
*** Null Pointer Exception: Etat
|
||
|
||
- Rendre impossibe de fabriquer un état qui devrait être impossible d'avoir.
|
||
- Pour aller plus loin voir, FRP, CQRS/ES, Elm-architecture, etc...
|
||
|
||
*** Erreur due à une typo
|
||
|
||
#+BEGIN_SRC haskell
|
||
data Foo x = LongNameWithPossibleError x
|
||
...
|
||
foo (LongNameWithPosibleError x) = ...
|
||
#+END_SRC
|
||
*Erreur à la compilation*:
|
||
Le nom d'un champ n'est pas une string
|
||
(voir les objets JSON).
|
||
|
||
*** Echange de parameters
|
||
|
||
#+BEGIN_SRC haskell
|
||
data Personne = Personne { uid :: Int, age :: Int }
|
||
foo :: Int -> Int -> Personne -- ??? uid ou age?
|
||
#+END_SRC
|
||
|
||
#+BEGIN_SRC haskell
|
||
newtype UID = UID Int deriving (Eq)
|
||
data Personne = Personne { uid :: UID, age :: Int }
|
||
foo :: UDI -> Int -> Personne -- Impossible de confondre
|
||
#+END_SRC
|
||
|
||
*** Changement intempestif d'un Etat Global
|
||
|
||
#+BEGIN_SRC haskell
|
||
foo :: GlobalState -> x
|
||
#+END_SRC
|
||
*~foo~ ne peut pas changer =GlobalState=*
|
||
|
||
* Organisation du Code
|
||
*** Grands Concepts
|
||
|
||
Procedure vs Functions:
|
||
|
||
| Gestion d'une configuration globale |
|
||
| Gestion d'un état global |
|
||
| Gestion des Erreurs |
|
||
| Gestion des IO |
|
||
|
||
*** Monades
|
||
|
||
Pour chacun de ces /problèmes/ il existe une monade:
|
||
|
||
| Gestion d'une configuration globale | ~Reader~ |
|
||
| Gestion d'un état global | ~State~ |
|
||
| Gestion des Erreurs | ~Either~ |
|
||
| Gestion des IO | ~IO~ |
|
||
|
||
*** Effets
|
||
|
||
Gestion de plusieurs Effets dans la même fonction:
|
||
|
||
- MTL
|
||
- Free Monad
|
||
- Freer Monad
|
||
|
||
Idée: donner à certaines sous-fonction accès à une partie des effets seulement.
|
||
|
||
Par exemple:
|
||
- limiter une fonction à la lecture de la DB mais pas l'écriture.
|
||
- limiter l'écriture à une seule table
|
||
- interdire l'écriture de logs
|
||
- interdire l'écriture sur le disque dur
|
||
- etc...
|
||
|
||
*** Exemple dans un code réel (1)
|
||
|
||
#+BEGIN_SRC haskell
|
||
-- | ConsumerBot type, the main monad in which the bot code is written with.
|
||
-- Provide config, state, logs and IO
|
||
type ConsumerBot m a =
|
||
( MonadState ConsumerState m
|
||
, MonadReader ConsumerConf m
|
||
, MonadLog (WithSeverity Doc) m
|
||
, MonadBaseControl IO m
|
||
, MonadSleep m
|
||
, MonadPubSub m
|
||
, MonadIO m
|
||
) => m a
|
||
#+END_SRC
|
||
|
||
*** Exemple dans un code réel (2)
|
||
|
||
#+BEGIN_SRC haskell
|
||
bot :: Manager
|
||
-> RotatingLog
|
||
-> Chan RedditComment
|
||
-> TVar RedbotConfs
|
||
-> Severity
|
||
-> IO ()
|
||
bot manager rotLog pubsub redbots minSeverity = do
|
||
TC.setDefaultPersist TC.filePersist
|
||
let conf = ConsumerConf
|
||
{ rhconf = RedditHttpConf { _connMgr = manager }
|
||
, commentStream = pubsub
|
||
}
|
||
void $ autobot
|
||
& flip runReaderT conf
|
||
& flip runStateT (initState redbots)
|
||
& flip runLoggingT (renderLog minSeverity rotLog)
|
||
#+END_SRC
|
||
|
||
|
||
** Règles *pragmatiques*
|
||
|
||
*** Organisation en fonction de la complexité
|
||
|
||
#+BEGIN_QUOTE
|
||
Make it work, make it right, make it fast
|
||
#+END_QUOTE
|
||
|
||
- Simple: directement IO (YOLO!)
|
||
- Medium: Haskell Design Patterns: The Handle Pattern:
|
||
https://jaspervdj.be/posts/2018-03-08-handle-pattern.html
|
||
- Medium (bis): MTL / Free / Freeer / Effects...
|
||
- Gros: Three Layer Haskell Cake:
|
||
http://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
|
||
+ Layer 1: Imperatif
|
||
+ Orienté Objet (Level 2 / 2') + Fonctionnel
|
||
|
||
*** 3 couches
|
||
|
||
- *Imperatif*:
|
||
ReaderT IO
|
||
+ Insérer l'état dans une ~TVar~, ~MVar~ ou ~IORef~ (concurrence)
|
||
- *Orienté Objet*: + Handle / MTL / Free...
|
||
+ donner des access ~UserDB~, ~AccessTime~, ~APIHTTP~...
|
||
- *Fonctionnel*: Business Logic ~f : Handlers -> Inputs -> Command~
|
||
|
||
*** Services / Lib
|
||
|
||
Service: ~init~ / ~start~ / ~close~ + methodes...
|
||
Lib: methodes sans état interne.
|
||
|
||
* Conclusion
|
||
*** Pourquoi Haskell?
|
||
|
||
- avantage compétitif: qualité & productivité hors norme
|
||
- change son approche de la programmation
|
||
- les concepts appris sont utilisables dans tous les languages
|
||
- permet d'aller là où aucun autre langage ne peut vous amener
|
||
- Approfondissement sans fin:
|
||
- Théorie: théorie des catégories, théorie des types homotopiques, etc...
|
||
- Optim: compilateur
|
||
- Qualité: tests, preuves
|
||
- Organisation: capacité de contraindre de très haut vers très bas
|
||
|
||
*** Avantage compétitif
|
||
|
||
- France, Europe du sud & Functional Programming
|
||
- Coût Maintenance >> production d'un nouveau produit
|
||
- Coût de la refactorisation
|
||
- "Make it work, Make it right, Make it fast" moins cher.
|
||
|
||
*** Pour la suite
|
||
|
||
A chacun de choisir, livres, tutoriels, videos, chat, etc...
|
||
|
||
- Voici une liste de resources : https://www.haskell.org/documentation
|
||
- Mon tuto rapide : [[http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/][Haskell the Hard Way]]
|
||
- Moteurs de recherche par type : [[http://hayoo.fh-wedel.de][hayoo]] & [[http://haskell.org/hoogle][hoogle]]
|
||
- Communauté & News : http://haskell.org/news & ~#haskell-fr~ sur freenode
|
||
- Libs: https://hackage.haskell.org & https://stackage.org
|
||
|
||
* Appendix
|
||
*** STM: Exemple (Concurrence) (1/2)
|
||
|
||
#+BEGIN_SRC java
|
||
class Account {
|
||
float balance;
|
||
synchronized void deposit(float amount){
|
||
balance += amount; }
|
||
synchronized void withdraw(float amount){
|
||
if (balance < amount) throw new OutOfMoneyError();
|
||
balance -= amount; }
|
||
synchronized void transfert(Account other, float amount){
|
||
other.withdraw(amount);
|
||
this.deposit(amount); }
|
||
}
|
||
#+END_SRC
|
||
|
||
Situation d'interblocage typique. (A transfert vers B et B vers A).
|
||
|
||
*** STM: Exemple (Concurrence) (2/2)
|
||
|
||
#+BEGIN_SRC haskell
|
||
deposit :: TVar Int -> Int -> STM ()
|
||
deposit acc n = do
|
||
bal <- readTVar acc
|
||
writeTVar acc (bal + n)
|
||
withdraw :: TVar Int -> Int -> STM ()
|
||
withdraw acc n = do
|
||
bal <- readTVar acc
|
||
if bal < n then retry
|
||
writeTVar acc (bal - n)
|
||
transfer :: TVar Int -> TVar Int -> Int -> STM ()
|
||
transfer from to n = do
|
||
withdraw from n
|
||
deposit to n
|
||
#+END_SRC
|
||
|
||
- pas de lock explicite, composition naturelle dans ~transfer~.
|
||
- si une des deux opération échoue toute la transaction échoue
|
||
- le système de type force cette opération a être atomique: ~atomically :: STM a -> IO a~
|