Notes accompagnant la présentation "Introduction à la programmation fonctionnelle avec Haskell" du OpenCode 01-12-2011

haskell.txt

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