Haskell Language
Utiliser GHCi

Remarques

Démarrer GHCi

Tapez ghci à l'invite du shell pour démarrer GHCI.

$ ghci
GHCi, version 8.0.1: http://www.haskell.org/ghc/  :? for help
Prelude> 

Modification de l'invite par défaut GHCi

Par défaut, l'invite de GHCI affiche tous les modules que vous avez chargés dans votre session interactive. Si vous avez beaucoup de modules chargés, cela peut être long:

Prelude Data.List Control.Monad> -- etc

La commande :set prompt modifie l'invite pour cette session interactive.

Prelude Data.List Control.Monad> :set prompt "foo> "
foo> 

Pour modifier l'invite de manière permanente, ajoutez :set prompt "foo> " dans le fichier de configuration GHCi .

Le fichier de configuration GHCi

GHCi utilise un fichier de configuration dans ~/.ghci . Un fichier de configuration consiste en une séquence de commandes que GHCi exécutera au démarrage.

$ echo ":set prompt \"foo> \"" > ~/.ghci
$ ghci
GHCi, version 8.0.1: http://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from ~/.ghci
foo> 

Chargement d'un fichier

La commande :l ou :load vérifie et charge un fichier.

$ echo "f = putStrLn \"example\"" > example.hs
$ ghci
GHCi, version 8.0.1: http://www.haskell.org/ghc/  :? for help
ghci> :l example.hs
[1 of 1] Compiling Main               ( example.hs, interpreted )
Ok, modules loaded: Main.
ghci> f
example

Quitter GHCi

Vous pouvez quitter GHCi simplement avec :q ou :quit

ghci> :q
Leaving GHCi.

ghci> :quit
Leaving GHCi.

Sinon, le raccourci CTRL + D ( Cmd + D pour OSX) a le même effet que :q .

Rechargement d'un fichier déjà chargé

Si vous avez chargé un fichier dans GHCi (par exemple en utilisant :l filename.hs ) et que vous avez modifié le fichier dans un éditeur en dehors de GHCi vous devez recharger le fichier avec :r ou :reload afin d'utiliser des changements, d' où vous n'avez pas besoin de saisir à nouveau le nom du fichier.

ghci> :r
OK, modules loaded: Main.

ghci> :reload
OK, modules loaded: Main.

Points d'arrêt avec GHCi

GHCi prend en charge les points d'arrêt de style impératif en dehors de la boîte avec du code interprété (code qui a été :loaded ).

Avec le programme suivant:

-- mySum.hs
doSum n = do
  putStrLn ("Counting to " ++ (show n))
  let v = sum [1..n]
  putStrLn ("sum to " ++ (show n) ++ " = " ++ (show v))

chargé dans GHCi:

Prelude> :load mySum.hs 
[1 of 1] Compiling Main             ( mySum.hs, interpreted )
Ok, modules loaded: Main.
*Main> 

Nous pouvons maintenant définir des points d'arrêt en utilisant des numéros de ligne:

*Main> :break 2
Breakpoint 0 activated at mySum.hs:2:3-39

et GHCi s'arrêtera à la ligne correspondante lorsque nous exécuterons la fonction:

*Main> doSum 12
Stopped at mySum.hs:2:3-39
_result :: IO () = _
n :: Integer = 12
[mySum.hs:2:3-39] *Main> 

Il peut être déroutant de savoir où nous en sommes dans le programme, nous pouvons donc utiliser :list pour clarifier:

[mySum.hs:2:3-39] *Main> :list
1  doSum n = do
2    putStrLn ("Counting to " ++ (show n))   -- GHCi will emphasise this line, as that's where we've stopped
3    let v = sum [1..n]

Nous pouvons imprimer des variables et continuer l'exécution aussi:

[mySum.hs:2:3-39] *Main> n
12
:continue 
Counting to 12
sum to 12 = 78
*Main> 

Déclarations multilignes

L'instruction :{ commence le mode multiligne et :} termine. En mode multiligne, GHCi interprétera les nouvelles lignes comme des points-virgules et non comme la fin d’une instruction.

ghci> :{
ghci| myFoldr f z [] = z
ghci| myFoldr f z (y:ys) = f y (myFoldr f z ys)
ghci| :}
ghci> :t myFoldr
myFoldr :: (a -> b -> b) -> b -> [a] -> b