Haskell Language
Usando GHCi

Observaciones

Iniciando GHCi

Escriba ghci en un intérprete de comandos de shell para iniciar GHCI.

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

Cambiar el indicador predeterminado de GHCi

De forma predeterminada, el indicador de GHCI muestra todos los módulos que ha cargado en su sesión interactiva. Si tienes muchos módulos cargados esto puede alargarse:

Prelude Data.List Control.Monad> -- etc

El comando :set prompt cambia el prompt para esta sesión interactiva.

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

Para cambiar la solicitud de forma permanente, agregue :set prompt "foo> " al archivo de configuración de GHCi .

El archivo de configuración de GHCi.

GHCi usa un archivo de configuración en ~/.ghci . Un archivo de configuración consta de una secuencia de comandos que GHCi ejecutará en el inicio.

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

Cargando un archivo

El :l o :load comando de :load comprueba y carga un archivo.

$ 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

Dejar de fumar GHCi

Puede abandonar GHCi simplemente con :q o :quit

ghci> :q
Leaving GHCi.

ghci> :quit
Leaving GHCi.

Alternativamente, el acceso directo CTRL + D ( Cmd + D para OSX) tiene el mismo efecto que :q .

Recargando un archivo ya cargado

Si ha cargado un archivo en GHCi (por ejemplo, utilizando :l filename.hs ) y ha cambiado el archivo en un editor fuera de GHCi, debe volver a cargar el archivo con :r o :reload para hacer uso de los cambios, por lo tanto no es necesario escribir de nuevo el nombre del archivo.

ghci> :r
OK, modules loaded: Main.

ghci> :reload
OK, modules loaded: Main.

Puntos de ruptura con GHCi

GHCi admite puntos de interrupción de estilo imperativo fuera de la caja con código interpretado (código que se ha :loaded ).

Con el siguiente programa:

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

cargado en GHCi:

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

Ahora podemos establecer puntos de interrupción utilizando números de línea:

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

y GHCi se detendrá en la línea correspondiente cuando ejecutemos la función:

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

Puede ser confuso dónde estamos en el programa, por lo que podemos usar :list para aclarar:

[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]

Podemos imprimir variables, y continuar la ejecución también:

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

Declaraciones multilínea

La instrucción :{ inicia el modo multilínea y :} finaliza. En el modo multilínea, GHCi interpretará las nuevas líneas como puntos y coma, no como el final de una instrucción.

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