X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fghci.xml;h=c2bceeae4c06d30690b4012b2c10885949b576f1;hb=059f2d7be7cc02d093ce51f0bbd68f5e5ebe527d;hp=5daa29c9a12eb6faf5d9c6db5834e449bd9c5baa;hpb=878ce92d0559e10a083b6983f2d23380086026d8;p=ghc-hetmet.git
diff --git a/docs/users_guide/ghci.xml b/docs/users_guide/ghci.xml
index 5daa29c..c2bceea 100644
--- a/docs/users_guide/ghci.xml
+++ b/docs/users_guide/ghci.xml
@@ -28,8 +28,11 @@
$ ghci
-GHCi, version 6.8.1: http://www.haskell.org/ghc/ :? for help
+GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help
+Loading package ghc-prim ... linking ... done.
+Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
+Loading package ffi-1.0 ... linking ... done.
Prelude>
@@ -202,12 +205,12 @@ Ok, modules loaded: Main.
very often, and use the interpreter for the code being actively
developed.
- When loading up source files with :load,
- GHCi looks for any corresponding compiled object files, and will
- use one in preference to interpreting the source if possible. For
- example, suppose we have a 4-module program consisting of modules
- A, B, C, and D. Modules B and C both import D only,
- and A imports both B & C:
+ When loading up source modules with :load,
+ GHCi normally looks for any corresponding compiled object files,
+ and will use one in preference to interpreting the source if
+ possible. For example, suppose we have a 4-module program
+ consisting of modules A, B, C, and D. Modules B and C both import
+ D only, and A imports both B & C:
A
/ \
@@ -298,6 +301,34 @@ Compiling A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
+ The automatic loading of object files can sometimes lead to
+ confusion, because non-exported top-level definitions of a module
+ are only available for use in expressions at the prompt when the
+ module is interpreted (see ). For
+ this reason, you might sometimes want to force GHCi to load a
+ module using the interpreter. This can be done by prefixing
+ a * to the module name or filename when
+ using :load, for example
+
+
+Prelude> :load *A
+Compiling A ( A.hs, interpreted )
+*A>
+
+
+When the * is used, GHCi ignores any
+ pre-compiled object code and interprets the module. If you have
+ already loaded a number of modules as object code and decide that
+ you wanted to interpret one of them, instead of re-loading the whole
+ set you can use :add *M to specify that you want
+ M to be interpreted (note that this might cause
+ other modules to be interpreted too, because compiled modules cannot
+ depend on interpreted ones).
+
+To always compile everything to object code and never use the
+ interpreter, use the -fobject-code option (see
+ ).
+
HINT: since GHCi will only use a compiled object file if it
can be sure that the compiled version is up-to-date, a good technique
when working on a large program is to occasionally run
@@ -306,7 +337,6 @@ Ok, modules loaded: A, B, C, D.
interpreter. As you modify code, the changed modules will be
interpreted, but the rest of the project will remain
compiled.
-
@@ -537,10 +567,14 @@ Compiling Main ( Main.hs, interpreted )
scopes from multiple modules, in any mixture of
* and non-* forms. GHCi
combines the scopes from all of these modules to form the scope
- that is in effect at the prompt. For technical reasons, GHCi
- can only support the *-form for modules which
- are interpreted, so compiled modules and package modules can
- only contribute their exports to the current scope.
+ that is in effect at the prompt.
+
+ NOTE: for technical reasons, GHCi can only support the
+ *-form for modules that are interpreted.
+ Compiled modules and package modules can only contribute their
+ exports to the current scope. To ensure that GHCi loads the
+ interpreted version of a module, add the *
+ when loading the module, e.g. :load *M.The scope is manipulated using the
:module command. For example, if the current
@@ -555,10 +589,12 @@ hello
Prelude IO>
- (Note: you can use import M as an
- alternative to :module +M, and
+ (Note: you can use conventional
+ haskell import syntax as
+ well, but this does not support
+ * forms).
:module can also be shortened to
- :m). The full syntax of the
+ :m. The full syntax of the
:module command is:
@@ -602,12 +638,48 @@ Prelude IO>
+ :module and
+ :load
+
+ It might seem that :module and
+ :load do similar things: you can use both
+ to bring a module into scope. However, there is a clear
+ difference. GHCi is concerned with two sets of modules:
+
+
+
+ The set of modules that are
+ currently loaded. This set is
+ modified
+ by :load, :add
+ and :reload.
+
+
+
+ The set of modules that are currently in
+ scope at the prompt. This set is modified
+ by :module, and it is also set
+ automatically
+ after :load, :add,
+ and :reload.
+
+
+
+ You cannot add a module to the scope if it is not
+ loaded. This is why trying to
+ use :module to load a new module results
+ in the message “module M is not
+ loaded”.
+
+
+ Qualified namesTo make life slightly easier, the GHCi prompt also
behaves as if there is an implicit import
qualified declaration for every module in every
- package, and every module currently loaded into GHCi.
+ package, and every module currently loaded into GHCi. This
+ behaviour can be disabled with the flag .
@@ -747,12 +819,12 @@ it <- e
ghci> reverse []
What should GHCi do? Strictly speaking, the program is ambiguous. show (reverse [])
- (which is what GHCi computes here) has type Show a => a and how that displays depends
+ (which is what GHCi computes here) has type Show a => String and how that displays depends
on the type a. For example:
- ghci> (reverse []) :: String
+ ghci> reverse ([] :: String)
""
- ghci> (reverse []) :: [Int]
+ ghci> reverse ([] :: [Int])
[]
However, it is tiresome for the user to have to specify the type, so GHCi extends Haskell's type-defaulting
@@ -845,10 +917,12 @@ def = toEnum 0
GHCi contains a simple imperative-style debugger in which you can
stop a running computation in order to examine the values of
variables. The debugger is integrated into GHCi, and is turned on by
- default: no flags are required to enable the debugging facilities. There
- is one major restriction: breakpoints and single-stepping are only
- available in interpreted modules; compiled code is
- invisible to the debugger.
+ default: no flags are required to enable the debugging
+ facilities. There is one major restriction: breakpoints and
+ single-stepping are only available in interpreted modules;
+ compiled code is invisible to the debuggerNote that packages
+ only contain compiled code, so debugging a package requires
+ finding its source and loading that directly..
The debugger provides the following:
@@ -883,9 +957,12 @@ def = toEnum 0
There is currently no support for obtaining a “stack
- trace”, but the tracing and history features provide a useful
- second-best, which will often be enough to establish the context of an
- error.
+ trace”, but the tracing and history features provide a
+ useful second-best, which will often be enough to establish the
+ context of an error. For instance, it is possible to break
+ automatically when an exception is thrown, even if it is thrown
+ from within compiled code (see ).
Breakpoints and inspecting variables
@@ -1422,7 +1499,7 @@ a :: a
*Main> :set -fbreak-on-exception
*Main> :trace qsort ("abc" ++ undefined)
-"Stopped at <exception thrown>
+“Stopped at <exception thrown>
_exception :: e
[<exception thrown>] *Main> :hist
-1 : qsort.hs:3:24-38
@@ -1707,13 +1784,16 @@ $ ghci -lm
- :addmodule ...
+ :add*module ...
:addAdd module(s) to the
current target set, and perform a
- reload.
+ reload. Normally pre-compiled code for the module will be
+ loaded if available, or otherwise the module will be
+ compiled to byte-code. Using the *
+ prefix forces the module to be loaded as byte-code.
@@ -2084,7 +2164,7 @@ Prelude> :. cmds.ghci
- :loadmodule ...
+ :load*module ...
:load
@@ -2101,6 +2181,11 @@ Prelude> :. cmds.ghci
to unload all the currently loaded modules and
bindings.
+ Normally pre-compiled code for a module will be loaded
+ if available, or otherwise the module will be compiled to
+ byte-code. Using the * prefix forces a
+ module to be loaded as byte-code.
+
After a :load command, the current
context is set to:
@@ -2251,6 +2336,16 @@ bar
+ :run
+ :run
+
+
+ See :main.
+
+
+
+
+ :setoption...:set
@@ -2306,7 +2401,9 @@ bar
Inside prompt, the sequence
%s is replaced by the names of the
modules currently in scope, and %% is
- replaced by %.
+ replaced by %. If prompt
+ starts with " then it is parsed as a Haskell String;
+ otherwise it is treated as a literal string.
@@ -2662,6 +2759,22 @@ Prelude> :set -fno-glasgow-exts
:set like this. The changes won't take effect
until the next :load, though.)
+ Once you have a library of GHCi macros, you may want
+ to source them from separate files, or you may want to source
+ your .ghci file into your running GHCi
+ session while debugging it
+
+
+:def source readFile
+
+
+ With this macro defined in your .ghci
+ file, you can use :source file to read GHCi
+ commands from file. You can find (and contribute!-)
+ other suggestions for .ghci files on this Haskell
+ wiki page: GHC/GHCi
+
Two command-line options control whether the
startup files files are read:
@@ -2810,6 +2923,13 @@ Prelude> :set -fno-glasgow-exts
because this is normally what you want in an interpreter:
output appears as it is generated.
+
+ If you want line-buffered behaviour, as in GHC, you can
+ start your program thus:
+
+ main = do { hSetBuffering stdout LineBuffering; ... }
+
+
@@ -2819,7 +2939,6 @@ Prelude> :set -fno-glasgow-exts