Create a gist now

Instantly share code, notes, and snippets.

Notes accompagnant la présentation "Introduction à la programmation fonctionnelle avec Haskell" du OpenCode 01-12-2011
Haskell (ghci)
Types de base
2
2 + 3.0
False
True == False
2 /= 2
2 == 2
1 == True
Tout est une fonction, même ==
(==) 1 2
(==) 1 1
Haskell considère infixe une fonction composée uniquement de symboles.
Parfois, on aimerait qu'une fonction soit infixe pour plus de clarté:
mod 7 5
On peut forcer une fonction à devenir infixe avec backtick.
7 `mod` 5
Explorer le type des objets
:t True
:t 2
:t 2.0
:t 'A'
:t "hello"
On voit que hello est en fait une liste de chars.
On peut aussi explorer les types des fonctions!
:t mod
mod est une fonction qui prend 2 éléments de type Integral et retourne un Integral.
Listes
Notation avec []
[1,2,3]
Ajout d'un élément à la tête
1 : [2,3,4]
'H' : "ello"
Concaténation
[1,2] ++ [3,4]
"Hel" ++ "lo"
Manipulation
head [1,2,3]
tail "Hello"
Intervalles
[1..10]
Avec "stepping"
[1,3..10]
Infini!
[1..]
head [1..]
Lazy évaluation
take 5 [1..]
Génération de liste (list comprehensions)
[ 2*x | x <- [0..], x^2 > 3 ]
"S is the set of all numbers "2 times x" where x is an item in the set of natural numbers (), for which x squared is greater than 3."
Manipulations avancées
map (1+) [1,2,3]
Voici un "lamba" (fonction anonyme déclarée sur place)
map (\x -> x + 1) [1,2,3]
Sommation avec fold (reduce)
foldl (+) 0 [1,2,3,4]
foldl (\a e -> a + e) 0 [1,2,3,4]
Factorielle
foldl (*) 1 [1,2,3,4]
Fonctions d'ordre supérieur
(à écrire dans un fichier externe, charger avec :l fichier.hs)
plus x y = x + y
On peut regarder les types des fonctions
:t plus
On peut spécifier le type d'une fonction
plus :: Int -> Int -> Int
:l os1.hs
:t plus
Application partielle de fonction
La fonction "plus" est automatiquement applicable partiellement.
let plus2 = plus 2
:t plus2
plus2 5
x est figé à 2 pour tous les appels, et la fonction ne prend plus qu'un seul argument!
Fonction qui prend une fonction en argument:
fun :: (Int -> Int -> Int) -> Int -> Int
fun fn x = fn x 2
fun (+) 4
Effets de bord
main = do
putStrLn "Hello world"
Avec le mot clé "do", on change en mode "séquence d'actions"
Récursivité (dans un fichier externe)
On définit les cas de base.
fac 0 = 1
On définit le reste par rapport au cas de base:
fac n = n * fac (n - 1)
Fibonacci
fib 0 = 0
fib 1 = 1
fib n = fib (n - 2) + fib (n - 1)
Syntaxe avec des "guards"
fib n
| n == 0 = 0
| n == 1 = 1
| otherwise = fib (n - 2) + fib (n - 1)
Avec les listes
len :: [a] -> Integer
len [] = 0
len (x:xs) = 1 + len xs
x c'est le premier élément (head)
xs c'est le reste (tail)
Dans ce cas ci, on pourrait omettre le x en le remplaçant par _ (catch all)
len [] = 0
len (_:xs) = 1 + len xs
On pourrait aussi ajouter un guard pour une liste à un seul élément
len [] = 0
len [_] = 1
len (_:xs) = 1 + len xs
Compilation
$ ghc -O --make os1.hs -o os1.bin
$ ./os1.bin
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment