Ligne de commande

GHCI

$ ghci

Prelude> :l myfunctions # chargement du fichier myfunction.hs
Prelude> :r             # recharger le dernier fichier

Prelude> :set prompt "ghci> " 
Prelude> :t objet      # affiche le type d'un objet, littéral, fonction, ...

Fichiers

Extension: ghci
Chargement: (ghci  et Prelude> :l filename)

Types

Int : [2147483647..-2147483648] # avec contrainte 32 bit ou 64 bit
Integer : [..] # sans contrainte
Float 
Double 
Bool
Char
String
List
Tuples (), (1,2), (1,2,3), (1,2,3,4), ...
Ordering (GT, LT, EQ)

Language

Entiers: 0, 1, 2, 3, ..., 100, ...
Négatifs: (-1), ... (-100), ... # la sortie de ghci est -1 sans les parenthèses
Flottant: (-4.0), ..., 4.0, 4.1, ...  (un flottant peut additionné un entier/négatif)

Opérateurs:
() Parenthèse 

* Multiplication
/ Division (flottante)

+ Addition
- Soustraction

Exemple:
2 + 15 # 17
5 / 2  # 2.5, on peut aussi écrire 5/2 (sans espace)

===========================

Booléen
True
False

Opérateurs:
()  parenthèse
&& ET 
|| OU 
not  Non


=========================
Liste:
[1,2,3]        ou 1:2:3:[]
['a','b','c']  ou 'a':'b':'c':[]
["abc", "def"] ou [['a','b','c'], ['d','e','f']]
[1..3]         donne [1,2,3]
[2,4..10]      donne [2,4,6,8,10]
[20,19..15]    donne [20,19,18,17,16,15]
[0.1, 0.3 .. 1] donne une liste non précise (problème de précision des flottants)
[13,26..]      tous les multiples de 13
[x*2 | x <- [1..10]] les dix premiers multiples de 2

# prédicat = condition
# fonction sur x,y | tel que x dans la liste, y dans la liste, prédicat, prédicat, prédicat
# f x*y | x <- xs, y <- ys, x <= 5, y >= 6
[x*2 | x <- [1..10], x*2 >= 12] les dix premiers multiples de 2 qui sont plus grand que 12
[1 | _ <- [1..6]] donne [1,1,1,1,1,1]


Opérateurs:
List ++ List    Concaténation     #  [1,2,3] ++ [4,5,6] donne [1,2,3,4,5,6]
Élément : List  (cons: ajouté un élément au début) # 1:[2,3]  donne [1,2,3], 'a':"bc" donne "abc" ou ['a','b','c']
List !! Number  Élément à la position Number (commence par 0)  # ['a','b','c'] !! 1  donne 'b'

Comparaisons: (si les éléments peuvent être comparés, du premier élément au dernier]
List > List 
List < List
List == List # [3,4,2] == [3,4,2]

=========================
Caractère
'a'..'z'

Chaînes:
"abc" ou ['a','b','c']

Opérateurs:
++ Concaténation #  "a" ++ "b"

=========================
Tuples
(1,2)  : Tuples avec 1 et 2
(1,"Two") : Tuples avec un entier et une chaînes

Triples
(1,2,3) 
("a",2,"3")

4-Tuples
(1,2,3,4)

Si présent dans une liste, les types doivent toujours correspondent.


===========================
Opérateur de comparaison

Type: booléen, nombre, chaîne de caractère, caractère, ...

==   Égalité
/=   Différence (il faut penser à ≠)

============================

# les fonctions ont toujours précédences sur les opérateurs, sauf ().
# les fonctions à deux paramètres f p1 p2 peuvent être réécrites: p1 `f` p2

Fonctions
Integer div Integer Integer # div 92 10 donne 9, (-92) (10) donne -10, (-92) (-10) donne 9.
Integer mod Integer Interger # modulo,   8 `mod` 7 donne 1
Boolean even Integer         # even 3 donne False, even 2 donne True 
Boolean odd Integer          # odd 3 donne True, odd 2 donne False 


Integer succ Integer   # succ 1 donne 2
Float   succ Float     # succ 1.1 donne 2.1

Integer min Integer Integer # min 3 1 donne 1
Float   min Float Float     # min 3.3 1.1 donne 1.1  (si un Integer est utilisé, retourne Float)

Integer max Integer Integer # max 3 1 donne 3
Float   max Float Float     # min 3.3 1.1 donne 3.3


Element head List    # head [5,4,3] donne 5, exception si vide
List tail List       # list [5,4,3] donne [4,3], exception si vide
Element last List    # last [5,4,3] donne 3, exception si vide
List init List       # init [5,4,3] donne [5,4], exception si vide
Integer length List  # length [2,4,6] donne 3
Boolean null List    # null [] donne True, null [1,2,3] donne False
List reverse List    # reverse [5,4,3] donne [3,4,5]
List take Integer List # take 2 [5,4,3] donne [5,4]  (fonctionne aussi avec 0 qui retourne [])
List drop Integer List # drop 2 [5,4,3] donne [3]
Element maximum List   # maximum [5,4,3] donne 5
Element minimum List   # maximum [5,4,3] donne 3
Number sum List        # sum [5,4,3] donne 12
Number product List    # product [5,4,3] donne 60
Boolean elem Element List # elem 4 [5,4,3] donne True (est élément de)
List cycle List        # génère une liste infinie. cycle [1,2,3] donne [1,2,3,1,2,3,1,..]
List repeat Element    # génère une liste infinie. repeat 5 donne [5,5,5,5,5,...]
List replicate Integer Element # génère une liste de x élément replicate 5 'a' donne ['a','a','a','a','a'] ou "aaaaa"

ListOfTuple zip List List # crée une liste de tuple avec les élément de la première liste et de la deuxième liste correspondante (length = min length List1 length List2)

Element fst Tuple     # fst (1,2) donne 1 # fst = first
Element snd Tuple     # snd (1,2) donne 2 # snd = second


string show Element   # show 3 donne "3"
Element read string   # read "3" + 0 donne 3
                      # read "3" :: Int   donne 3
Element minBound :: Type
Element maxBound :: Type

Num fromIntegral (Integral a, Num b) => a


============================
Conditions

#if retourne une valeur
if conditionVraie then retourSiVraie else retourSiFausse

Exemple:
doubleSmallNumber x = if x > 10 then x else x*2

============================
Déclaration de fonctions (dans les fichiers .hs):

# Le nom de la fonction peut contenir des lettres, des guillemets simples '.
# ne peut commencer par des lettres majuscules

nomFonction [parameter1] [...] = calcul

Exemple:
doubleMe x = x + x
doubleUs x y = x*2 + y*2
test = "bla"


Déclaration de fonctions (dans ghci):
let nomFonction parameter = calcul
Exemple:
let doubleMe x = x + x

Utilisation: doubleMe 10   # donne 20

============================
Déclaration de fonction avec type
doubleMe :: Int -> Int
doubleMe x = x + x

doubleUs :: Int -> Int -> Int
doubleMe x y = x + x + y + y

# autre syntaxe
doubleUs :: Int, Int -> Int
doubleMe x y = x + x + y + y

============================
Les opérateurs sont des fonctions.
S'il n'y a que des caractères spéciaux, ils sont automatiquement en mode "infixe".
Mais on peut les utiliser en mode normal avec des parenthèse

1 == 1  # True
(==) 1 1 # True 

============================
Typeclass

Exemple: Eq, Ord, Show, Read, Enum, Bounded, Num, Integral, Floating

=> Class Constraint

Hyperliens...

Lire les commentaires | Laisser un commentaire