<screen>
$ 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>
</screen>
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 <xref linkend="ghci-scope" />). For
- this reason, if you ask GHCi to load a filename rather than a
- module name (e.g. <literal>:load Main.hs</literal> rather than
- <literal>:load Main</literal>) then any existing object file will
- be ignored and the module will be interpreted rather than
- compiled. Using <literal>-fobject-code</literal> disables this
- behaviour (see <xref linkend="ghci-obj" />).</para>
+ this reason, you might sometimes want to force GHCi to load a
+ module using the interpreter. This can be done by prefixing
+ a <literal>*</literal> to the module name or filename when
+ using <literal>:load</literal>, for example</para>
+
+<screen>
+Prelude> :load *A
+Compiling A ( A.hs, interpreted )
+*A>
+</screen>
+
+<para>When the <literal>*</literal> 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 <literal>:add *M</literal> to specify that you want
+ <literal>M</literal> to be interpreted (note that this might cause
+ other modules to be interpreted too, because compiled modules cannot
+ depend on interpreted ones).</para>
+
+<para>To always compile everything to object code and never use the
+ interpreter, use the <literal>-fobject-code</literal> option (see
+ <xref linkend="ghci-obj" />).</para>
<para>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
<para>NOTE: for technical reasons, GHCi can only support the
<literal>*</literal>-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 <literal>:load</literal>.</para>
+ exports to the current scope. To ensure that GHCi loads the
+ interpreted version of a module, add the <literal>*</literal>
+ when loading the module, e.g. <literal>:load *M</literal>.</para>
<para>The scope is manipulated using the
<literal>:module</literal> command. For example, if the current
Prelude IO>
</screen>
- <para>(Note: you can use <literal>import M</literal> as an
- alternative to <literal>:module +M</literal>, and
+ <para>(Note: you can use conventional
+ haskell <literal>import</literal> syntax as
+ well, but this does not support
+ <literal>*</literal> forms).
<literal>:module</literal> can also be shortened to
- <literal>:m</literal>). The full syntax of the
+ <literal>:m</literal>. The full syntax of the
<literal>:module</literal> command is:</para>
<screen>
</para>
<sect3>
+ <title><literal>:module</literal> and
+ <literal>:load</literal></title>
+
+ <para>It might seem that <literal>:module</literal> and
+ <literal>:load</literal> 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:</para>
+
+ <itemizedlist>
+ <listitem>
+ <para>The set of modules that are
+ currently <emphasis>loaded</emphasis>. This set is
+ modified
+ by <literal>:load</literal>, <literal>:add</literal>
+ and <literal>:reload</literal>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>The set of modules that are currently <emphasis>in
+ scope</emphasis> at the prompt. This set is modified
+ by <literal>:module</literal>, and it is also set
+ automatically
+ after <literal>:load</literal>, <literal>:add</literal>,
+ and <literal>:reload</literal>.</para>
+ </listitem>
+ </itemizedlist>
+
+ <para>You cannot add a module to the scope if it is not
+ loaded. This is why trying to
+ use <literal>:module</literal> to load a new module results
+ in the message “<literal>module M is not
+ loaded</literal>”.</para>
+ </sect3>
+
+ <sect3 id="ghci-import-qualified">
<title>Qualified names</title>
<para>To make life slightly easier, the GHCi prompt also
behaves as if there is an implicit <literal>import
qualified</literal> declaration for every module in every
- package, and every module currently loaded into GHCi.</para>
+ package, and every module currently loaded into GHCi. This
+ behaviour can be disabled with the flag <option>-fno-implicit-import-qualified</option><indexterm><primary><option>-fno-implicit-import-qualified</option></primary></indexterm>.</para>
</sect3>
<sect3>
ghci> reverse []
</programlisting>
What should GHCi do? Strictly speaking, the program is ambiguous. <literal>show (reverse [])</literal>
- (which is what GHCi computes here) has type <literal>Show a => a</literal> and how that displays depends
+ (which is what GHCi computes here) has type <literal>Show a => String</literal> and how that displays depends
on the type <literal>a</literal>. For example:
<programlisting>
- ghci> (reverse []) :: String
+ ghci> reverse ([] :: String)
""
- ghci> (reverse []) :: [Int]
+ ghci> reverse ([] :: [Int])
[]
</programlisting>
However, it is tiresome for the user to have to specify the type, so GHCi extends Haskell's type-defaulting
<screen>
*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
<varlistentry>
<term>
- <literal>:add</literal> <replaceable>module</replaceable> ...
+ <literal>:add</literal> <optional><literal>*</literal></optional><replaceable>module</replaceable> ...
<indexterm><primary><literal>:add</literal></primary></indexterm>
</term>
<listitem>
<para>Add <replaceable>module</replaceable>(s) to the
current <firstterm>target set</firstterm>, and perform a
- reload.</para>
+ 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 <literal>*</literal>
+ prefix forces the module to be loaded as byte-code.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
- <literal>:load</literal> <replaceable>module</replaceable> ...
+ <literal>:load</literal> <optional><literal>*</literal></optional><replaceable>module</replaceable> ...
<indexterm><primary><literal>:load</literal></primary></indexterm>
</term>
<listitem>
to unload all the currently loaded modules and
bindings.</para>
+ <para>Normally pre-compiled code for a module will be loaded
+ if available, or otherwise the module will be compiled to
+ byte-code. Using the <literal>*</literal> prefix forces a
+ module to be loaded as byte-code.</para>
+
<para>After a <literal>:load</literal> command, the current
context is set to:</para>
<varlistentry>
<term>
+ <literal>:run</literal>
+ <indexterm><primary><literal>:run</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>See <literal>:main</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:set</literal> <optional><replaceable>option</replaceable>...</optional>
<indexterm><primary><literal>:set</literal></primary></indexterm>
</term>
Inside <replaceable>prompt</replaceable>, the sequence
<literal>%s</literal> is replaced by the names of the
modules currently in scope, and <literal>%%</literal> is
- replaced by <literal>%</literal>.</para>
+ replaced by <literal>%</literal>. If <replaceable>prompt</replaceable>
+ starts with " then it is parsed as a Haskell String;
+ otherwise it is treated as a literal string.</para>
</listitem>
</varlistentry>
because this is normally what you want in an interpreter:
output appears as it is generated.
</para>
+ <para>
+ If you want line-buffered behaviour, as in GHC, you can
+ start your program thus:
+ <programlisting>
+ main = do { hSetBuffering stdout LineBuffering; ... }
+ </programlisting>
+ </para>
</listitem>
</varlistentry>
</variablelist>
<!-- Emacs stuff:
;;; Local Variables: ***
- ;;; mode: xml ***
;;; sgml-parent-document: ("users_guide.xml" "book" "chapter") ***
;;; End: ***
-->