-- commentaire : directive pour le compilateur ghc 
:opt no-lint

-- expression simple
1

-- additionner, soustraire
3 + 5

-- multiplier 
3 * 5

-- diviser
5 / 2

-- plusieurs calculs
1 - 2 * 3
1 - (2 * 3)
(1 - 2) * 3

-- vrai
True

-- opérateurs booléens
True || False
True && False
not True

-- tester l'égalité de booléens
True == False

-- tester l'(in)égalité de nombre
1 /= 2

1 == True

"2" + 3

-- quel est le type de True ?
:type True

-- quel est le type de 'a' ?
:t 'a'

-- quel est le type de "Abc" ?
:t "Abc"

:t (True, True)

:t (True, 'a', "cat")

-- quel est le type de 1 ?
:t 1

-- calculer la racine carrée de 16
sqrt 16

-- calculer le minimum de 2 nombres
min 2 4

min 2 -2

min 2 (-2)

-- on a déjà vu un exemple de fonction dans la première partie...

-- quel est le type de l'expression que nous venons d'évaluer ?
:t not True

-- quel est le type de la fonction not ?
:t not

-- quel est le type de la fonction sqrt ?
:t sqrt

even 15
even 16

:t even

div 5 2

5 / 2

(/) 5 2

:t div
:t (/)

5 `div` 2

pi
round pi

(sin pi)^2 + (cos pi)^2

-- l'évaluation de cette expression provoque une erreur
div 10 0

f x = 1
:t f

f (div 10 0)

f x = x
:t f

f (div 10 0)

a = 1

a

a = 2

a

:t a

a = a + 1

-- a

a = 1
a = 2

-- myAdd

-- myMinimumOfThree

-- isPrime

-- syracuse en utlisant where et des guardes

(1,2)

(1,2,3)

:t ('a','b')

:t ('a',True)

-- ceci n'est pas un tuple
:t ('a')

(1,(2,3))

fst ("a",'b')

snd ("a",'b')

[1,2,3]

:t [True,False,False]

[]

:t []

:t [[1,2],[],[1,2,3]]

[1..10]

[10..1]

[10,9..1]

[1,3..10]

-- [1,3..]

1 : [2, 3]

"Hello" : ["World"]

:t (:)

head [1,2,3,4,5]
tail [1,2,3,4,5]

[1..10] ++ [11,12]

:t (++)

([2,4],[2,4,5])

[(2,4),(5,5),('a','b')]

1 : (2,3)

(2,4) : (2,3)

(2,4) : []

(2,4) ++ []

head [1..10] == [1]

head [1..10] + 100

[1..10] + 100

length [1..2^10]

elem 'a' ['A'..'Z']

last [1,2,3,4,5]
init [1,2,3,4,5]

"abc" == ['a','b','c']

'a': "bcd"

words "Il etait une fois... \n ou deux"

show 42

:t show

read "42" :: Int

:t read

import Data.Char

isAlpha '4'
isAlpha 'A'

isDigit 'a'

toUpper 'a'

ord 'a'

intToText :: Int -> String
intToText 0 = "zero"
intToText 1 = "un"
intToText 2 = "deux"
intToText _ = "non compris entre 0 et 2"

intToText 1

intToText 3

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

factorial 5

pow :: Int -> Int -> Int
pow x 0 = 1
pow x 1 = x
pow x n = x * pow x (n - 1)

pow 2 10

and' :: Bool -> Bool -> Bool
and' True  True  = True
and' True  False = False
and' False True  = False
and' False False = False

and' (10 == 2 *5) ('a' == head ['a'])

and' :: Bool -> Bool -> Bool
and' True  b  = b
and' False _  = False

and' :: Bool -> Bool -> Bool
and' True True = True
and' _    _    = False

first3 :: (a, b, c) -> a
first3 (x, _, _) = x

second3 :: (a, b, c) -> b
second3 (_, y, _) = y

third3 :: (a, b, c) -> c
third3 (_, _, z) = z

first3 (10,20,30)
second3 (10,20,30)
third3 (10,20,30)

distance :: (Double, Double) -> (Double, Double) -> Double
distance (x1, y1) (x2, y2) = sqrt ((x2 - x1) ^ 2 + (y2 - y1) ^ 2)

distance (3,2) (1,8)

distance :: (Double, Double) -> (Double, Double) -> Double
distance (x, y) (0, 0) = sqrt (x ^ 2 + y ^ 2)
distance (0, 0) (x, y) = sqrt (x ^ 2 + y ^ 2)
distance p1      p2    = sqrt ((x2 - x1) ^ 2 + (y2 - y1) ^ 2)
    where
        (x1, y1) = p1
        (x2, y2) = p2

distance (0,0) (1,8)

intToText :: Int -> String
intToText 0 = "zero"
intToText 1 = "un"
intToText 2 = "deux"

intToText 3

-- mot d'exactement trois caractères commençant par un 'a'
test :: [Char] -> Bool
test ['a', _, _] = True
test _           = False

test "abc"
test "abcd"
test "cba"

isEmpty :: [a] -> Bool
isEmpty [] = True
isEmpty _  = False

isEmpty []
isEmpty [1..]

atLeastTwo :: [a] -> Bool
atLeastTwo []  = False
atLeastTwo [_] = False
atLeastTwo _   = True

atLeastTwo [1]
atLeastTwo [1..10]

sum' :: [Int] -> Int
sum' []     = 0
sum' (x:xs) = x + sum' xs

size :: [a] -> Int
size []     = 0
size (_:xs) = 1 + size xs

atLeastTwo :: [a] -> Bool
atLeastTwo (x:y:xs) = True
atLeastTwo _        = False

-- on suppose que la liste ne peut pas être vide, on verra plus tard comment gérer ça.
last' :: [a] -> a
last' [x]      = x
last' (_ : xs) = last' xs

last' [1..100]

elem' :: Eq a => a -> [a] -> Bool
elem' _ []       = False
elem' e (x : xs) = x == e || elem' e xs

elem' 5 [1,2,3,4,5,6,7]
elem' 15 [1,2,3,4,5,6,7]

reverse ["avion","ballon","chat"]

reverse' :: [a] -> [a]
reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

reverse' [1..10]

take 10 [1..]

:t take

drop 10 ['a'..'z']

zip [1,2,3,4,5] ['a','b','c','d','e']
zip [1,2,3] ['a','b','c','d','e']
zip [1,2,3,4,5] ['a','b','c']

unzip [(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e')]

import Data.List

intersperse 0 [1..10]
intersperse ',' ['a'..'z']

intercalate [0] [[1,2],[3,4],[5,6]]
intercalate "-" ["b","cd","efg"]

Première partie : pourquoi apprendre à programmer en Haskell ?¶

Qu'est-ce que Haskell ?¶

C'est un langage fonctionnel.¶

Haskell est un langage de programmation fonctionnel pur.¶

Haskell est un langage paresseux.¶

Haskell est un langage typé statiquement.¶

Haskell est un langage compilé.¶

Premiers pas¶

Premières expressions, nombres, calcul¶

Booléens¶

Haskell est fortement typé¶

Types "basiques"¶

On verra le système de types plus en détail au prochain cours.¶

Haskell est un langage fonctionnel¶

Haskell est un langage paresseux¶

On a dit "pas d'affectation de variable"... vraiment ?¶

Quels sont les inconvénients d'un langage fonctionnel tel que Haskell ?¶

Mais alors, pourquoi apprendre Haskell ?¶

Éléments de correction de la première partie du TP¶

Deuxième partie : on commence à programmer¶

Structures de données et un peu de syntaxe¶

Tuples¶

Premières listes¶

Quelques fonctions utiles pour les listes¶

Les basiques¶

Exercice¶

Quelques fonctions supplémentaires sur les listes¶

Chaînes de caractères¶

Pattern matching¶

On commence avec quelques exemples simples :¶

Pattern matching pour les listes¶

Exemples classiques¶

Deuxième partie du TP¶