X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fghci.xml;h=80205954e5ecf0b2e9ee299eda9fa679478073e8;hb=4d8c7c976104d2e39a1183967ec0f254a0fc0a47;hp=c5b5f7c19fd7aabb30d22d216350ad03fefd6d1c;hpb=3897d02a5c0deb5c3bfda3299a28bbef525eba84;p=ghc-hetmet.git diff --git a/docs/users_guide/ghci.xml b/docs/users_guide/ghci.xml index c5b5f7c..8020595 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> @@ -302,12 +305,29 @@ Ok, modules loaded: A, B, C, D. 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, if you ask GHCi to load a filename rather than a - module name (e.g. :load Main.hs rather than - :load Main) then any existing object file will - be ignored and the module will be interpreted rather than - compiled. Using -fobject-code disables this - behaviour (see ). + 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 @@ -552,9 +572,9 @@ Compiling Main ( Main.hs, interpreted ) 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. This is why GHCi will always - interpret, not compile, a module if you specify its filename - rather than its module name to :load. + 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 @@ -569,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: @@ -616,12 +638,48 @@ Prelude IO> + <literal>:module</literal> and + <literal>:load</literal> + + 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 names To 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 . @@ -761,16 +819,16 @@ 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 - rules (Section 4.3.4 of the Haskell 98 Report (Revised)) as follows. The + rules (Section 4.3.4 of the Haskell 2010 Report) as follows. The standard rules take each group of constraints (C1 a, C2 a, ..., Cn a) for each type variable a, and defaults the type variable if @@ -1441,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 @@ -1726,13 +1784,16 @@ $ ghci -lm - :add module ... + :add *module ... :add Add 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. @@ -1882,8 +1943,7 @@ maybe :: b -> (a -> b) -> Maybe a -> b used, respectively. Tags for all the functions, constructors and types in the currently loaded modules are created. All modules must be interpreted for these commands to work. - See also . - + @@ -2103,7 +2163,7 @@ Prelude> :. cmds.ghci - :load module ... + :load *module ... :load @@ -2120,6 +2180,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: @@ -2270,6 +2335,16 @@ bar + :run + :run + + + See :main. + + + + + :set option... :set @@ -2325,7 +2400,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. @@ -2845,6 +2922,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; ... } + + @@ -2854,7 +2938,6 @@ Prelude> :set -fno-glasgow-exts