Sections
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...
Dernière modification: 2014-02-23 16:47:45 par Yan Morin
Hébergé par ProgYSM