Add -fghci-hist-size=N to set the number of previous steps stored by :trace
[ghc.git] / docs / users_guide / ghci.xml
index 6e54ace..c59f4b3 100644 (file)
@@ -4,7 +4,7 @@
   <indexterm><primary>GHCi</primary></indexterm>
   <indexterm><primary>interpreter</primary><see>GHCi</see></indexterm>
   <indexterm><primary>interactive</primary><see>GHCi</see></indexterm>
-  
+
   <para>GHCi<footnote>
       <para>The &lsquo;i&rsquo; stands for &ldquo;Interactive&rdquo;</para>
     </footnote>
@@ -33,17 +33,16 @@ 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> 
+Prelude>
 </screen>
 
     <para>There may be a short pause while GHCi loads the prelude and
     standard libraries, after which the prompt is shown. As the banner
-    says, you can type <literal>:?</literal> to see the list of commands
-    available, and a half line description of each of them.</para>
-
-    <para>We'll explain most of these commands as we go along.  For
-    Hugs users: many things work the same as in Hugs, so you should be
-    able to get going straight away.</para>
+    says, you can type <literal>:?</literal> to see the list of
+    commands available, and a half line description of each of them.
+    We'll explain most of these commands as we go along, and there is
+    complete documentation for all the commands in
+      <xref linkend="ghci-commands" />.</para>
 
     <para>Haskell expressions can be typed at the prompt:</para>
     <indexterm><primary>prompt</primary><secondary>GHCi</secondary>
@@ -54,12 +53,19 @@ Prelude> 1+2
 3
 Prelude> let x = 42 in x / 9
 4.666666666666667
-Prelude> 
+Prelude>
 </screen>
 
     <para>GHCi interprets the whole line as an expression to evaluate.
-    The expression may not span several lines - as soon as you press
-    enter, GHCi will attempt to evaluate it.</para>
+    The expression may not span several lines - as soon as you press enter,
+    GHCi will attempt to evaluate it.</para>
+
+    <para>In Haskell, a <literal>let</literal> expression is followed
+    by <literal>in</literal>.  However, in GHCi, since the expression
+    can also be interpreted in the <literal>IO</literal> monad,
+    a <literal>let</literal> binding with no accompanying
+    <literal>in</literal> statement can be signalled by an empty line,
+    as in the above example.</para>
   </sect1>
 
   <sect1 id="loading-source-files">
@@ -130,7 +136,7 @@ Ok, modules loaded: Main.
       <title>Modules vs. filenames</title>
       <indexterm><primary>modules</primary><secondary>and filenames</secondary></indexterm>
       <indexterm><primary>filenames</primary><secondary>of modules</secondary></indexterm>
-      
+
       <para>Question: How does GHC find the filename which contains
       module <replaceable>M</replaceable>?  Answer: it looks for the
       file <literal><replaceable>M</replaceable>.hs</literal>, or
@@ -235,7 +241,7 @@ Ok, modules loaded: A, B, C, D.
     because the source and everything it depends on
     is unchanged since the last compilation.</para>
 
-    <para>At any time you can use the command 
+    <para>At any time you can use the command
     <literal>:show modules</literal>
     to get a list of the modules currently loaded
     into GHCi:</para>
@@ -258,7 +264,7 @@ A                ( A.hs, interpreted )
 *Main> :reload
 Compiling D                ( D.hs, interpreted )
 Ok, modules loaded: A, B, C, D.
-*Main> 
+*Main>
 </screen>
 
     <para>Note that module D was compiled, but in this instance
@@ -352,10 +358,10 @@ Prelude> 5+5
 </screen>
 </para>
 
-<sect2><title>I/O actions at the prompt</title>
+<sect2 id="actions-at-prompt"><title>I/O actions at the prompt</title>
 
 <para>GHCi does more than simple expression evaluation at the prompt.
-If you type something of type <literal>IO a</literal> for some
+If you enter an expression of type <literal>IO a</literal> for some
     <literal>a</literal>, then GHCi <emphasis>executes</emphasis> it
     as an IO-computation.
 <screen>
@@ -364,6 +370,12 @@ Prelude> "hello"
 Prelude> putStrLn "hello"
 hello
 </screen>
+This works even if the type of the expression is more general,
+provided it can be <emphasis>instantiated</emphasis> to <literal>IO a</literal>.  For example
+<screen>
+Prelude> return True
+True
+</screen>
 Furthermore, GHCi will print the result of the I/O action if (and only
 if):
 <itemizedlist>
@@ -385,7 +397,7 @@ hello
       <title>Using <literal>do-</literal>notation at the prompt</title>
       <indexterm><primary>do-notation</primary><secondary>in GHCi</secondary></indexterm>
       <indexterm><primary>statements</primary><secondary>in GHCi</secondary></indexterm>
-      
+
       <para>GHCi actually accepts <firstterm>statements</firstterm>
       rather than just expressions at the prompt.  This means you can
       bind values and functions to names, and use them in future
@@ -410,10 +422,10 @@ Prelude>
       it as we did above.</para>
 
       <para>If <option>-fprint-bind-result</option> is set then
-      GHCi will print the result of a statement if and only if: 
+      GHCi will print the result of a statement if and only if:
        <itemizedlist>
          <listitem>
-           <para>The statement is not a binding, or it is a monadic binding 
+           <para>The statement is not a binding, or it is a monadic binding
              (<literal>p &lt;- e</literal>) that binds exactly one
              variable.</para>
          </listitem>
@@ -457,9 +469,9 @@ Prelude> add 1 2
 3
 Prelude>
 </screen>
-        <para>However, this quickly gets tedious when defining functions 
+        <para>However, this quickly gets tedious when defining functions
         with multiple clauses, or groups of mutually recursive functions,
-        because the complete definition has to be given on a single line, 
+        because the complete definition has to be given on a single line,
         using explicit braces and semicolons instead of layout:</para>
 <screen>
 Prelude> let { f op n [] = n ; f op n (h:t) = h `op` f op n t }
@@ -481,9 +493,9 @@ Prelude> g (*) 1 [1..3]
 </screen>
       <para>Such multiline commands can be used with any GHCi command,
       and the lines between <literal>:{</literal> and
-      <literal>:}</literal> are simply merged into a single line for 
+      <literal>:}</literal> are simply merged into a single line for
       interpretation. That implies that each such group must form a single
-      valid command when merged, and that no layout rule is used. 
+      valid command when merged, and that no layout rule is used.
       The main purpose of multiline commands is not to replace module
       loading but to make definitions in .ghci-files (see <xref
       linkend="ghci-dot-files"/>) more readable and maintainable.</para>
@@ -526,8 +538,138 @@ xs :: [Integer]
 
     </sect2>
 
+    <sect2 id="ghci-multiline">
+      <title>Multiline input</title>
+
+      <para>Apart from the <literal>:{ ... :}</literal> syntax for
+        multi-line input mentioned above, GHCi also has a multiline
+        mode, enabled by <literal>:set +m</literal>,
+        <indexterm><primary><literal>:set +m</literal></primary></indexterm>
+        in which GHCi detects automatically when the current statement
+        is unfinished and allows further lines to be added.  A
+        multi-line input is terminated with an empty line.  For example:</para>
+
+<screen>
+Prelude> :set +m
+Prelude> let x = 42
+Prelude|
+</screen>
+
+       <para>Further bindings can be added to
+       this <literal>let</literal> statement, so GHCi indicates that
+       the next line continues the previous one by changing the
+       prompt.  Note that layout is in effect, so to add more bindings
+         to this <literal>let</literal> we have to line them up:</para>
+
+<screen>
+Prelude> :set +m
+Prelude> let x = 42
+Prelude|     y = 3
+Prelude| 
+Prelude>
+</screen>
+
+       <para>Explicit braces and semicolons can be used instead of
+         layout, as usual:</para>
+
+<screen>
+Prelude> do {
+Prelude| putStrLn "hello"
+Prelude| ;putStrLn "world"
+Prelude| }
+hello
+world
+Prelude>
+</screen>
+
+       <para>Note that after the closing brace, GHCi knows that the
+         current statement is finished, so no empty line is required.</para>
+
+       <para>Multiline mode is useful when entering monadic
+         <literal>do</literal> statements:</para>
+
+<screen>
+Control.Monad.State> flip evalStateT 0 $ do
+Control.Monad.State| i &lt;- get
+Control.Monad.State| lift $ do
+Control.Monad.State|   putStrLn "Hello World!"
+Control.Monad.State|   print i
+Control.Monad.State|
+"Hello World!"
+0
+Control.Monad.State>
+</screen>
+
+   <para>During a multiline interaction, the user can interrupt and
+   return to the top-level prompt.</para>
+
+<screen>
+Prelude> do
+Prelude| putStrLn "Hello, World!"
+Prelude| ^C
+Prelude>
+</screen>
+    </sect2>
+
+    <sect2 id="ghci-decls">
+      <title>Type, class and other declarations</title>
+
+      <para>At the GHCi
+      prompt you can also enter any top-level Haskell declaration,
+      including <literal>data</literal>, <literal>type</literal>, <literal>newtype</literal>, <literal>class</literal>, <literal>instance</literal>, <literal>deriving</literal>,
+      and <literal>foreign</literal> declarations.  For
+      example:</para>
+
+<screen>
+Prelude> data T = A | B | C deriving (Eq, Ord, Show, Enum)
+Prelude> [A ..]
+[A,B,C]
+Prelude> :i T
+data T = A | B | C      -- Defined at &lt;interactive>:2:6
+instance Enum T -- Defined at &lt;interactive>:2:45
+instance Eq T -- Defined at &lt;interactive>:2:30
+instance Ord T -- Defined at &lt;interactive>:2:34
+instance Show T -- Defined at &lt;interactive>:2:39
+</screen>
+
+    <para>As with ordinary variable bindings, later definitions shadow
+    earlier ones, so you can re-enter a declaration to fix a problem
+    with it or extend it.  But there's a gotcha: when a new type
+    declaration shadows an older one, there might be other
+    declarations that refer to the old type.  The thing to remember is
+    that the old type still exists, and these other declarations still
+    refer to the old type.  However, while the old and the new type
+    have the same name, GHCi will treat them as distinct.  For
+    example:</para>
+
+<screen>
+Prelude> data T = A | B
+Prelude> let f A = True; f B = False
+Prelude> data T = A | B | C
+Prelude> f A
+
+&lt;interactive>:2:3:
+    Couldn't match expected type `main::Interactive.T'
+                with actual type `T'
+    In the first argument of `f', namely `A'
+    In the expression: f A
+    In an equation for `it': it = f A
+Prelude> 
+</screen>
+
+    <para>The old, shadowed, version of <literal>T</literal> is
+      displayed as <literal>main::Interactive.T</literal> by GHCi in
+      an attempt to distinguish it from the new <literal>T</literal>,
+      which is displayed as simply <literal>T</literal>.</para>
+
+    <para>Class and type-family instance declarations are simply added to the list of available isntances, with one
+    exception. Since type-family instances are not permitted to overlap, but you might want to re-define one,
+    a type-family instance <emphasis>replaces</emphasis> any earlier type instance with an identical left hand side.
+    (See <xref linkend="type-families"/>.)</para>
+    </sect2>
+
     <sect2 id="ghci-scope">
-      <title>What's really in scope at the prompt?</title> 
+      <title>What's really in scope at the prompt?</title>
 
       <para>When you type an expression at the prompt, what
       identifiers and types are in scope?  GHCi provides a flexible
@@ -538,8 +680,12 @@ xs :: [Integer]
 <screen>Prelude></screen>
 
       <para>Which indicates that everything from the module
-      <literal>Prelude</literal> is currently in scope.  If we now
-      load a file into GHCi, the prompt will change:</para>
+      <literal>Prelude</literal> is currently in scope; the visible
+      identifiers are exactly those that would be visible in a Haskell
+      source file with no <literal>import</literal>
+      declarations.</para>
+
+      <para>If we now load a file into GHCi, the prompt will change:</para>
 
 <screen>
 Prelude> :load Main.hs
@@ -576,24 +722,59 @@ Compiling Main             ( Main.hs, interpreted )
       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
-      scope is <literal>Prelude</literal>, then we can bring into
-      scope the exports from the module <literal>IO</literal> like
-      so:</para>
+      <para>To add modules to the scope, use ordinary Haskell
+      <literal>import</literal> syntax:</para>
 
 <screen>
-Prelude> :module +IO
-Prelude IO> hPutStrLn stdout "hello\n"
+Prelude> import System.IO
+Prelude System.IO> hPutStrLn stdout "hello\n"
 hello
-Prelude IO>
+Prelude System.IO>
+</screen>
+
+      <para>The full Haskell import syntax is supported, including
+      <literal>hiding</literal> and <literal>as</literal> clauses.
+      The prompt shows the modules that are currently imported, but it
+      omits details about <literal>hiding</literal>,
+      <literal>as</literal>, and so on.  To see the full story, use
+      <literal>:show imports</literal>:</para>
+
+<screen>
+Prelude> import System.IO
+Prelude System.IO> import Data.Map as Map
+Prelude System.IO Map> :show imports
+import Prelude -- implicit
+import System.IO
+import Data.Map as Map
+Prelude System.IO Map>
 </screen>
 
-      <para>(Note: you can use <literal>import M</literal> as an
-      alternative to <literal>:module +M</literal>, and
-      <literal>:module</literal> can also be shortened to 
-      <literal>:m</literal>). The full syntax of the
-      <literal>:module</literal> command is:</para>
+      <para>Note that the <literal>Prelude</literal> import is marked
+      as implicit.  It can be overriden with an explicit
+      <literal>Prelude</literal> import, just like in a Haskell
+      module.</para>
+
+      <para>Another way to manipulate the scope is to use the
+      <literal>:module</literal> command, which provides a way to do
+      two things that cannot be done with ordinary
+      <literal>import</literal> declarations:
+      <itemizedlist>
+        <listitem>
+          <para><literal>:module</literal> supports the
+          <literal>*</literal> modifier on modules, which opens the
+          full top-level scope of a module, rather than just its
+          exports.</para>
+        </listitem>
+        <listitem>
+          <para>Imports can be <emphasis>removed</emphasis> from the
+          context, using the syntax <literal>:module -M</literal>.
+          The <literal>import</literal> syntax is cumulative (as in a
+          Haskell module), so this is the only way to subtract from
+          the scope.</para>
+        </listitem>
+      </itemizedlist>
+      The full syntax of the <literal>:module</literal> command
+      is:</para>
 
 <screen>
 :module <optional>+|-</optional> <optional>*</optional><replaceable>mod<subscript>1</subscript></replaceable> ... <optional>*</optional><replaceable>mod<subscript>n</subscript></replaceable>
@@ -604,14 +785,12 @@ Prelude IO>
       scope, and <literal>-</literal> removes them.  Without either
       <literal>+</literal> or <literal>-</literal>, the current scope
       is replaced by the set of modules specified.  Note that if you
-      use this form and leave out <literal>Prelude</literal>, GHCi
-      will assume that you really wanted the
-      <literal>Prelude</literal> and add it in for you (if you don't
-      want the <literal>Prelude</literal>, then ask to remove it with
-      <literal>:m -Prelude</literal>).</para>
-
-      <para>The scope is automatically set after a
-      <literal>:load</literal> command, to the most recently loaded
+      use this form and leave out <literal>Prelude</literal>, an
+      implicit <literal>Prelude</literal> import will be added
+      automatically.</para>
+
+      <para>After a <literal>:load</literal> command, an automatic
+      import is added to the scope for the most recently loaded
       "target" module, in a <literal>*</literal>-form if possible.
       For example, if you say <literal>:load foo.hs bar.hs</literal>
       and <filename>bar.hs</filename> contains module
@@ -620,7 +799,23 @@ Prelude IO>
       interpreted, or if <literal>Bar</literal> is compiled it will be
       set to <literal>Prelude Bar</literal> (GHCi automatically adds
       <literal>Prelude</literal> if it isn't present and there aren't
-      any <literal>*</literal>-form modules).</para>
+      any <literal>*</literal>-form modules).  These
+      automatically-added imports can be seen with
+      <literal>:show imports</literal>:
+
+<screen>
+Prelude> :load hello.hs
+[1 of 1] Compiling Main             ( hello.hs, interpreted )
+Ok, modules loaded: Main.
+*Main> :show imports
+:module +*Main -- added automatically
+*Main>
+</screen>
+
+      and the automatically-added import is replaced the next time you
+      use <literal>:load</literal>, <literal>:add</literal>, or
+      <literal>:reload</literal>.  It can also be removed by
+      <literal>:module</literal> as with normal imports.</para>
 
       <para>With multiple modules in scope, especially multiple
       <literal>*</literal>-form modules, it is likely that name
@@ -646,20 +841,20 @@ Prelude IO>
 
         <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>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>, and can be shown with
+            <literal>:show modules</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>
+            scope</emphasis> at the prompt.  This set is modified by
+            <literal>import</literal>, <literal>:module</literal>, and
+            it is also modified automatically after
+            <literal>:load</literal>, <literal>:add</literal>, and
+            <literal>:reload</literal>, as described above.</para>
           </listitem>
         </itemizedlist>
 
@@ -739,13 +934,13 @@ bar
 
       </sect3>
     </sect2>
-  
+
 
     <sect2>
       <title>The <literal>it</literal> variable</title>
       <indexterm><primary><literal>it</literal></primary>
       </indexterm>
-      
+
       <para>Whenever an expression (or a non-binding statement, to be
       precise) is typed at the prompt, GHCi implicitly binds its value
       to the variable <literal>it</literal>.  For example:</para>
@@ -758,7 +953,7 @@ Prelude> it * 2
     <para>What actually happens is that GHCi typechecks the
     expression, and if it doesn't have an <literal>IO</literal> type,
     then it transforms it as follows: an expression
-    <replaceable>e</replaceable> turns into 
+    <replaceable>e</replaceable> turns into
 <screen>
 let it = <replaceable>e</replaceable>;
 print it
@@ -826,10 +1021,10 @@ it &lt;- <replaceable>e</replaceable>
   []
 </programlisting>
     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 <literal>(C1 a, C2 a, ..., Cn
     a)</literal> for each type variable <literal>a</literal>, and defaults the
-    type variable if 
+    type variable if
     <orderedlist>
         <listitem>
             <para>
@@ -904,7 +1099,66 @@ def = toEnum 0
     <literal>Integer</literal> then ghci gives an error when running a
     printf.
    </para>
+   <para>See also <xref linkend="actions-at-prompt"/> for how the monad of a computational
+   expression defaults to <literal>IO</literal> if possible.
+   </para>
     </sect2>
+
+   <sect2 id="ghci-interactive-print">
+     <title>Using a custom interactive printing function</title>
+     <para>[<emphasis role="bold">New in version 7.6.1</emphasis>]
+        By default, GHCi prints the result of expressions typed at the prompt
+        using the function <literal>System.IO.print</literal>. Its type
+        signature is <literal>Show a => a -> IO ()</literal>, and it works by
+        converting the value to <literal>String</literal> using
+        <literal>show</literal>.
+     </para>
+     <para>
+        This is not ideal in certain cases, like when the output is long, or
+        contains strings with non-ascii characters.
+     </para>
+     <para>
+       The <literal>-interactive-print</literal> flag allows to specify any
+       function of type <literal>C a => a -> IO ()</literal>, for some
+       constraint <literal>C</literal>, as the function for printing evaluated
+       expressions. The function can reside in any loaded module or any
+       registered package.
+     </para>
+     <para>
+       As an example, suppose we have following special printing module:
+       <programlisting>
+        module SpecPrinter where
+        import System.IO
+
+        sprint a = putStrLn $ show a ++ "!"
+       </programlisting>
+       The <literal>sprint</literal> function adds an exclamation mark at the
+       end of any printed value. Running GHCi with the command:
+       <programlisting>
+        ghci -interactive-print=SpecPrinter.sprinter SpecPrinter
+       </programlisting>
+       will start an interactive session where values with be printed using
+       <literal>sprint</literal>:
+       <programlisting>
+        *SpecPrinter> [1,2,3]
+        [1,2,3]!
+        *SpecPrinter> 42
+        42!
+       </programlisting>
+     </para>
+     <para>
+       A custom pretty printing function can be used, for example, to format
+       tree-like and nested structures in a more readable way.
+     </para>
+     <para>
+       The <literal>-interactive-print</literal> flag can also be used when
+       running GHC in <literal>-e mode</literal>:
+       <programlisting>
+        % ghc -e "[1,2,3]" -interactive-print=SpecPrinter.sprint SpecPrinter
+        [1,2,3]!
+       </programlisting>
+     </para>
+   </sect2>
   </sect1>
 
   <sect1 id="ghci-debugger">
@@ -927,7 +1181,7 @@ def = toEnum 0
         <listitem>
           <para>The ability to set a <firstterm>breakpoint</firstterm> on a
             function definition or expression in the program.  When the function
-            is called, or the expression evaluated, GHCi suspends 
+            is called, or the expression evaluated, GHCi suspends
             execution and returns to the prompt, where you can inspect the
             values of local variables before continuing with the
             execution.</para>
@@ -953,7 +1207,7 @@ def = toEnum 0
         </listitem>
       </itemizedlist>
     </para>
-      
+
     <para>There is currently no support for obtaining a &ldquo;stack
     trace&rdquo;, but the tracing and history features provide a
     useful second-best, which will often be enough to establish the
@@ -961,14 +1215,14 @@ def = toEnum 0
     automatically when an exception is thrown, even if it is thrown
     from within compiled code (see <xref
     linkend="ghci-debugger-exceptions" />).</para>
-      
+
     <sect2 id="breakpoints">
       <title>Breakpoints and inspecting variables</title>
-      
+
       <para>Let's use quicksort as a running example.  Here's the code:</para>
 
 <programlisting>
-qsort [] = [] 
+qsort [] = []
 qsort (a:as) = qsort left ++ [a] ++ qsort right
   where (left,right) = (filter (&lt;=a) as, filter (&gt;a) as)
 
@@ -982,7 +1236,7 @@ Prelude> :l qsort.hs
 [1 of 1] Compiling Main             ( qsort.hs, interpreted )
 Ok, modules loaded: Main.
 *Main>
-      </screen>       
+      </screen>
 
       <para>Now, let's set a breakpoint on the right-hand-side of the second
         equation of qsort:</para>
@@ -992,12 +1246,12 @@ Ok, modules loaded: Main.
 Breakpoint 0 activated at qsort.hs:2:15-46
 *Main>
 </programlisting>
-      
+
       <para>The command <literal>:break 2</literal> sets a breakpoint on line
         2 of the most recently-loaded module, in this case
         <literal>qsort.hs</literal>.   Specifically, it picks the
         leftmost complete subexpression on that line on which to set the
-        breakpoint, which in this case is the expression 
+        breakpoint, which in this case is the expression
         <literal>(qsort left ++ [a] ++ qsort right)</literal>.</para>
 
       <para>Now, we run the program:</para>
@@ -1018,8 +1272,8 @@ right :: [a]
         location, we can use the <literal>:list</literal> command:</para>
 
 <programlisting>
-[qsort.hs:2:15-46] *Main> :list 
-1  qsort [] = [] 
+[qsort.hs:2:15-46] *Main> :list
+1  qsort [] = []
 2  qsort (a:as) = qsort left ++ [a] ++ qsort right
 3    where (left,right) = (filter (&lt;=a) as, filter (&gt;a) as)
 </programlisting>
@@ -1092,7 +1346,7 @@ left = (_t1::[a])
       <para>The flag <literal>-fprint-evld-with-show</literal> instructs
       <literal>:print</literal> to reuse
       available <literal>Show</literal> instances when possible. This happens
-      only when the contents of the variable being inspected 
+      only when the contents of the variable being inspected
       are completely evaluated.</para>
 
 
@@ -1128,7 +1382,7 @@ _t1 :: [Integer]
 [qsort.hs:2:15-46] *Main> a
 8
 </screen>
-      
+
       <para>You might find it useful to use Haskell's
         <literal>seq</literal> function to evaluate individual thunks rather
         than evaluating the whole expression with <literal>:force</literal>.
@@ -1159,7 +1413,7 @@ _result :: [a]
 a :: a
 left :: [a]
 right :: [a]
-[qsort.hs:2:15-46] *Main> 
+[qsort.hs:2:15-46] *Main>
 </screen>
 
       <para>The execution continued at the point it previously stopped, and has
@@ -1189,13 +1443,13 @@ right :: [a]
    :break <replaceable>line</replaceable>
    :break <replaceable>line</replaceable> <replaceable>column</replaceable>
    :break <replaceable>module</replaceable> <replaceable>line</replaceable>
-   :break <replaceable>module</replaceable> <replaceable>line</replaceable> <replaceable>column</replaceable> 
+   :break <replaceable>module</replaceable> <replaceable>line</replaceable> <replaceable>column</replaceable>
 </screen>
 
       <para>When a breakpoint is set on a particular line, GHCi sets the
         breakpoint on the
         leftmost subexpression that begins and ends on that line.  If two
-        complete subexpressions start at the same 
+        complete subexpressions start at the same
         column, the longest one is picked.  If there is no complete
         subexpression on the line, then the leftmost expression starting on
         the line is picked, and failing that the rightmost expression that
@@ -1209,7 +1463,7 @@ right :: [a]
           and doesn't match others.  The best advice is to avoid tab
           characters in your source code altogether (see
           <option>-fwarn-tabs</option> in <xref linkend="options-sanity"
-            />).</para> 
+            />).</para>
 
       <para>If the module is omitted, then the most recently-loaded module is
         used.</para>
@@ -1243,7 +1497,7 @@ right :: [a]
 *Main> :delete 0
 *Main> :show breaks
 [1] Main qsort.hs:2:15-46
-</screen>        
+</screen>
 
         <para>To delete all breakpoints at once, use <literal>:delete *</literal>.</para>
 
@@ -1255,7 +1509,7 @@ right :: [a]
 
       <para>Single-stepping is a great way to visualise the execution of your
         program, and it is also a useful tool for identifying the source of a
-        bug. GHCi offers two variants of stepping. Use 
+        bug. GHCi offers two variants of stepping. Use
        <literal>:step</literal>  to enable all the
         breakpoints in the program, and execute until the next breakpoint is
         reached. Use <literal>:steplocal</literal> to limit the set
@@ -1274,7 +1528,7 @@ _result :: IO ()
         <replaceable>expr</replaceable></literal> begins the evaluation of
         <replaceable>expr</replaceable> in single-stepping mode.  If
         <replaceable>expr</replaceable> is omitted, then it single-steps from
-        the current breakpoint. <literal>:stepover</literal> 
+        the current breakpoint. <literal>:stepover</literal>
         works similarly.</para>
 
       <para>The <literal>:list</literal> command is particularly useful when
@@ -1282,9 +1536,9 @@ _result :: IO ()
 
 <screen>
 [qsort.hs:5:7-47] *Main> :list
-4  
+4
 5  main = print (qsort [8, 4, 0, 3, 1, 23, 11, 18])
-6  
+6
 [qsort.hs:5:7-47] *Main>
 </screen>
 
@@ -1297,9 +1551,9 @@ _result :: IO ()
 [qsort.hs:5:7-47] *Main> :step
 Stopped at qsort.hs:5:14-46
 _result :: [Integer]
-4  
+4
 5  main = print (qsort [8, 4, 0, 3, 1, 23, 11, 18])
-6  
+6
 [qsort.hs:5:14-46] *Main>
 </screen>
     </sect2>
@@ -1393,13 +1647,13 @@ _result :: [a]
 
 <screen>
 *Main&gt; :list qsort
-1  qsort [] = [] 
+1  qsort [] = []
 2  qsort (a:as) = qsort left ++ [a] ++ qsort right
 3    where (left,right) = (filter (&lt;=a) as, filter (&gt;a) as)
-4  
+4
 *Main&gt; :b 1
 Breakpoint 1 activated at qsort.hs:1:11-12
-*Main&gt; 
+*Main&gt;
 </screen>
 
       <para>and then run a small <literal>qsort</literal> with
@@ -1444,7 +1698,7 @@ Logged breakpoint at qsort.hs:3:24-38
 _result :: [a]
 as :: [a]
 a :: a
-[-1: qsort.hs:3:24-38] *Main> 
+[-1: qsort.hs:3:24-38] *Main>
 </screen>
 
       <para>Note that the local variables at each step in the history have been
@@ -1461,8 +1715,7 @@ a :: a
       <para>The history is only available when
         using <literal>:trace</literal>; the reason for this is we found that
         logging each breakpoint in the history cuts performance by a factor of
-        2 or more.  GHCi remembers the last 50 steps in the history (perhaps in
-        the future we'll make this configurable).</para>
+        2 or more.  By default, GHCi remembers the last 50 steps in the history, but this can be changed with the <option>-fghci-hist-size=<replaceable>n</replaceable></option><indexterm><primary><option>&ndash;fghci-hist-size</option></primary></indexterm> option).</para>
     </sect2>
 
     <sect2 id="ghci-debugger-exceptions">
@@ -1474,7 +1727,8 @@ a :: a
         particular call to <literal>head</literal> in your program resulted in
         the error can be a painstaking process, usually involving
         <literal>Debug.Trace.trace</literal>, or compiling with
-        profiling and using <literal>+RTS -xc</literal> (see <xref
+        profiling and using <literal>Debug.Trace.traceStack</literal>
+        or <literal>+RTS -xc</literal> (see <xref
           linkend="prof-time-options" />).</para>
 
       <para>The GHCi debugger offers a way to hopefully shed some light on
@@ -1486,10 +1740,10 @@ a :: a
         we can't set a breakpoint on it directly.  For this reason, GHCi
         provides the flags <literal>-fbreak-on-exception</literal> which causes
         the evaluator to stop when an exception is thrown, and <literal>
-       -fbreak-on-error</literal>, which works similarly but stops only on 
-       uncaught exceptions. When stopping at an exception, GHCi will act 
+       -fbreak-on-error</literal>, which works similarly but stops only on
+       uncaught exceptions. When stopping at an exception, GHCi will act
        just as it does when a breakpoint is hit, with the deviation that it
-       will not show you any source code location. Due to this, these 
+       will not show you any source code location. Due to this, these
        commands are only really useful in conjunction with
         <literal>:trace</literal>, in order to log the steps leading up to the
         exception.  For example:</para>
@@ -1529,15 +1783,15 @@ as = 'b' : 'c' : (_t1::[Char])
 
     <sect2><title>Example: inspecting functions</title>
       <para>
-        It is possible to use the debugger to examine function values. 
+        It is possible to use the debugger to examine function values.
         When we are at a breakpoint and a function is in scope, the debugger
-        cannot show 
-        you the source code for it; however, it is possible to get some 
-        information by applying it to some arguments and  observing the result. 
+        cannot show
+        you the source code for it; however, it is possible to get some
+        information by applying it to some arguments and  observing the result.
       </para>
 
       <para>
-        The process is slightly complicated when the binding is polymorphic. 
+        The process is slightly complicated when the binding is polymorphic.
         We show the process by means of an example.
         To keep things simple, we will use the well known <literal>map</literal> function:
 <programlisting>
@@ -1561,9 +1815,9 @@ x :: a
 f :: a -> b
 xs :: [a]
 </screen>
-      GHCi tells us that, among other bindings, <literal>f</literal> is in scope. 
-      However, its type is not fully known yet,  
-      and thus it is not possible to apply it to any 
+      GHCi tells us that, among other bindings, <literal>f</literal> is in scope.
+      However, its type is not fully known yet,
+      and thus it is not possible to apply it to any
       arguments. Nevertheless, observe that the type of its first argument is the
       same as the type of <literal>x</literal>, and its result type is shared
         with <literal>_result</literal>.
@@ -1571,12 +1825,12 @@ xs :: [a]
 
       <para>
         As we demonstrated earlier (<xref linkend="breakpoints" />),  the
-        debugger has some intelligence built-in to update the type of 
-        <literal>f</literal> whenever the types of <literal>x</literal> or 
+        debugger has some intelligence built-in to update the type of
+        <literal>f</literal> whenever the types of <literal>x</literal> or
         <literal>_result</literal> are discovered.  So what we do in this
         scenario is
-        force <literal>x</literal> a bit, in order to recover both its type 
-      and the argument part of <literal>f</literal>.  
+        force <literal>x</literal> a bit, in order to recover both its type
+      and the argument part of <literal>f</literal>.
 <screen>
 *Main> seq x ()
 *Main> :print x
@@ -1585,7 +1839,7 @@ x = 1
       </para>
       <para>
         We can check now that as expected, the type of <literal>x</literal>
-        has been reconstructed, and with it the 
+        has been reconstructed, and with it the
         type of <literal>f</literal> has been too:</para>
 <screen>
 *Main> :t x
@@ -1595,7 +1849,7 @@ f :: Integer -> b
 </screen>
       <para>
         From here, we can apply f to any argument of type Integer and observe
-        the results. 
+        the results.
 <screen><![CDATA[
 *Main> let b = f 10
 *Main> :t b
@@ -1621,10 +1875,10 @@ Just 20
 *Main> map f [1..5]
 [Just 1, Just 2, Just 3, Just 4, Just 5]
 ]]></screen>
-      In the first application of <literal>f</literal>, we had to do 
+      In the first application of <literal>f</literal>, we had to do
       some more type reconstruction
-      in order to recover the result type of <literal>f</literal>. 
-      But after that, we are free to use 
+      in order to recover the result type of <literal>f</literal>.
+      But after that, we are free to use
       <literal>f</literal> normally.
      </para>
     </sect2>
@@ -1645,7 +1899,7 @@ Just 20
             CAF at the prompt again.</para>
         </listitem>
        <listitem><para>
-         Implicit parameters (see <xref linkend="implicit-parameters"/>) are only available 
+         Implicit parameters (see <xref linkend="implicit-parameters"/>) are only available
          at the scope of a breakpoint if there is an explicit type signature.
        </para>
         </listitem>
@@ -1693,7 +1947,7 @@ $ ghci -package readline
 GHCi, version 6.8.1: http://www.haskell.org/ghc/  :? for help
 Loading package base ... linking ... done.
 Loading package readline-1.0 ... linking ... done.
-Prelude> 
+Prelude>
 </screen>
 
       <para>The following command works to load new packages into a
@@ -1711,7 +1965,7 @@ Prelude> :set -package <replaceable>name</replaceable>
     <sect2>
       <title>Extra libraries</title>
       <indexterm><primary>libraries</primary><secondary>with GHCi</secondary></indexterm>
-      
+
       <para>Extra libraries may be specified on the command line using
       the normal <literal>-l<replaceable>lib</replaceable></literal>
       option.  (The term <emphasis>library</emphasis> here refers to
@@ -1827,28 +2081,37 @@ $ ghci -lm
           <indexterm><primary><literal>:browse</literal></primary></indexterm>
         </term>
        <listitem>
-         <para>Displays the identifiers defined by the module
+         <para>Displays the identifiers exported by the module
          <replaceable>module</replaceable>, which must be either
          loaded into GHCi or be a member of a package.  If
          <replaceable>module</replaceable> is omitted, the most
          recently-loaded module is used.</para>
 
-          <para>If the <literal>*</literal> symbol is placed before
-         the module name, then <emphasis>all</emphasis> the
-         identifiers in scope in <replaceable>module</replaceable> are
-         shown; otherwise the list is limited to the exports of
-         <replaceable>module</replaceable>.  The
-         <literal>*</literal>-form is only available for modules
-         which are interpreted; for compiled modules (including
-         modules from packages) only the non-<literal>*</literal>
-    form of <literal>:browse</literal> is available.
-    If the <literal>!</literal> symbol is appended to the
-    command, data constructors and class methods will be 
-    listed individually, otherwise, they will only be listed
-    in the context of their data type or class declaration. 
-    The <literal>!</literal>-form also annotates the listing 
-    with comments giving possible imports for each group of 
-    entries.</para>
+         <para>Like all other GHCi commands, the output is always 
+          displayed in the current GHCi scope (<xref linkend="ghci-scope"/>).</para>
+
+          <para>There are two variants of the browse command:
+          <itemizedlist>
+          <listitem>  
+             <para>If the <literal>*</literal> symbol is placed before
+            the module name, then <emphasis>all</emphasis> the
+            identifiers in scope in <replaceable>module</replaceable> 
+             (rather that just its exports) are shown. </para>
+
+             <para>The <literal>*</literal>-form is only available for modules
+            which are interpreted; for compiled modules (including
+            modules from packages) only the non-<literal>*</literal>
+             form of <literal>:browse</literal> is available.</para>
+          </listitem>
+          <listitem>
+          <para>Data constructors and class methods are usually
+          displayed in the context of their data type or class declaration.
+          However, if the <literal>!</literal> symbol is appended to the
+          command, thus <literal>:browse!</literal>, 
+          they are listed individually. 
+         The <literal>!</literal>-form also annotates the listing
+         with comments giving possible imports for each group of
+         entries.  Here is an example:
 <screen>
 Prelude> :browse! Data.Maybe
 -- not currently imported
@@ -1866,15 +2129,17 @@ data Maybe a = Nothing | Just a
 Nothing :: Maybe a
 maybe :: b -> (a -> b) -> Maybe a -> b
 </screen>
-  <para>
-    This output shows that, in the context of the current session, in the scope
-    of <literal>Prelude</literal>, the first group of items from
-    <literal>Data.Maybe</literal> have not been imported (but are available in
+    This output shows that, in the context of the current session (ie in the scope
+    of <literal>Prelude</literal>), the first group of items from
+    <literal>Data.Maybe</literal> are not in scope (althought they are available in
     fully qualified form in the GHCi session - see <xref
-      linkend="ghci-scope"/>), whereas the second group of items have been
-    imported via <literal>Prelude</literal> and are therefore available either
+      linkend="ghci-scope"/>), whereas the second group of items are in scope
+    (via <literal>Prelude</literal>) and are therefore available either
     unqualified, or with a <literal>Prelude.</literal> qualifier.
   </para>
+          </listitem>
+       </itemizedlist>
+      </para>
        </listitem>
       </varlistentry>
 
@@ -1915,7 +2180,7 @@ maybe :: b -> (a -> b) -> Maybe a -> b
 
       <varlistentry>
        <term>
-          <literal>:continue</literal> 
+          <literal>:continue</literal>
           <indexterm><primary><literal>:continue</literal></primary></indexterm>
         </term>
        <listitem><para>Continue the current evaluation, when stopped at a
@@ -1941,8 +2206,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.</para>
-          <para>See also <xref linkend="hasktags" />.</para>
-       </listitem>
+        </listitem>
       </varlistentry>
 
       <varlistentry>
@@ -2022,7 +2286,7 @@ Prelude> :. cmds.ghci
 
       <varlistentry>
        <term>
-          <literal>:delete * | <replaceable>num</replaceable> ...</literal> 
+          <literal>:delete * | <replaceable>num</replaceable> ...</literal>
           <indexterm><primary><literal>:delete</literal></primary></indexterm>
         </term>
        <listitem>
@@ -2050,7 +2314,7 @@ Prelude> :. cmds.ghci
 
       <varlistentry>
        <term>
-          <literal>:etags</literal> 
+          <literal>:etags</literal>
         </term>
        <listitem>
          <para>See <literal>:ctags</literal>.</para>
@@ -2116,10 +2380,12 @@ Prelude> :. cmds.ghci
           <indexterm><primary><literal>:history</literal></primary></indexterm>
         </term>
        <listitem>
-         <para>Display the history of evaluation steps.  With a number,
-            displays that many steps (default: 20).  For use with
-            <literal>:trace</literal>; see <xref
-              linkend="tracing" />.</para>
+         <para>Display the history of evaluation steps.  With a
+         number, displays that many steps (default: 20).  For use
+         with <literal>:trace</literal>; see <xref linkend="tracing"
+         />.  To set the number of history entries stored by GHCi,
+         use
+         <option>-fghci-hist-size=<replaceable>n</replaceable></option>.</para>
        </listitem>
       </varlistentry>
 
@@ -2140,23 +2406,27 @@ Prelude> :. cmds.ghci
          the location of its definition in the source.</para>
          <para>For types and classes, GHCi also summarises instances that
          mention them.  To avoid showing irrelevant information, an instance
-         is shown only if (a) its head mentions <replaceable>name</replaceable>, 
+         is shown only if (a) its head mentions <replaceable>name</replaceable>,
          and (b) all the other things mentioned in the instance
-         are in scope (either qualified or otherwise) as a result of 
+         are in scope (either qualified or otherwise) as a result of
          a <literal>:load</literal> or <literal>:module</literal> commands. </para>
        </listitem>
       </varlistentry>
 
       <varlistentry>
        <term>
-          <literal>:kind</literal> <replaceable>type</replaceable>
+          <literal>:kind</literal><optional><literal>!</literal></optional> 
+                        <replaceable>type</replaceable>
           <indexterm><primary><literal>:kind</literal></primary></indexterm>
         </term>
        <listitem>
          <para>Infers and prints the kind of
          <replaceable>type</replaceable>. The latter can be an arbitrary
            type expression, including a partial application of a type constructor,
-           such as <literal>Either Int</literal>.</para>
+           such as <literal>Either Int</literal>.  If you specify the 
+            optional "<literal>!</literal>", GHC will in addition normalise the type
+            by expanding out type synonyms and evaluating type-function applications,
+            and display the normalised result.</para>
        </listitem>
       </varlistentry>
 
@@ -2344,6 +2614,19 @@ bar
 
       <varlistentry>
        <term>
+          <literal>:script</literal> <optional><replaceable>n</replaceable></optional>
+         <literal>filename</literal>
+          <indexterm><primary><literal>:script</literal></primary></indexterm>
+        </term>
+       <listitem>
+    <para>Executes the lines of a file as a series of GHCi commands.  This command
+    is compatible with multiline statements as set by <literal>:set +m</literal>
+    </para>
+       </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term>
           <literal>:set</literal> <optional><replaceable>option</replaceable>...</optional>
           <indexterm><primary><literal>:set</literal></primary></indexterm>
         </term>
@@ -2436,6 +2719,28 @@ bar
 
       <varlistentry>
        <term>
+          <literal>:seti</literal> <optional><replaceable>option</replaceable>...</optional>
+          <indexterm><primary><literal>:seti</literal></primary></indexterm>
+        </term>
+       <listitem>
+          <para>
+            Like <literal>:set</literal>, but options set with
+            <literal>:seti</literal> affect only expressions and
+            commands typed at the prompt, and not modules loaded with
+            <literal>:load</literal> (in contrast, options set with
+            <literal>:set</literal> apply everywhere).  See <xref
+            linkend="ghci-interactive-options" />.
+          </para>
+          <para>
+            Without any arguments, displays the current set of options
+            that are applied to expressions and commands typed at the
+            prompt.
+          </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term>
           <literal>:show bindings</literal>
           <indexterm><primary><literal>:show bindings</literal></primary></indexterm>
         </term>
@@ -2467,6 +2772,18 @@ bar
 
       <varlistentry>
        <term>
+          <literal>:show imports</literal>
+          <indexterm><primary><literal>:show imports</literal></primary></indexterm>
+        </term>
+       <listitem>
+          <para>Show the imports that are currently in force, as
+          created by <literal>import</literal> and
+          <literal>:module</literal> commands.</para>
+       </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term>
           <literal>:show modules</literal>
           <indexterm><primary><literal>:show modules</literal></primary></indexterm>
         </term>
@@ -2523,7 +2840,7 @@ bar
 
       <varlistentry>
        <term>
-          <literal>:step [<replaceable>expr</replaceable>]</literal> 
+          <literal>:step [<replaceable>expr</replaceable>]</literal>
           <indexterm><primary><literal>:step</literal></primary></indexterm>
         </term>
        <listitem>
@@ -2599,8 +2916,9 @@ bar
   </sect1>
 
   <sect1 id="ghci-set">
-    <title>The <literal>:set</literal> command</title>
+    <title>The <literal>:set</literal> and <literal>:seti</literal> commands</title>
     <indexterm><primary><literal>:set</literal></primary></indexterm>
+    <indexterm><primary><literal>:seti</literal></primary></indexterm>
 
     <para>The <literal>:set</literal> command sets two types of
     options: GHCi options, which begin with
@@ -2626,6 +2944,18 @@ bar
       <variablelist>
        <varlistentry>
          <term>
+            <literal>+m</literal>
+            <indexterm><primary><literal>+m</literal></primary></indexterm>
+          </term>
+         <listitem>
+           <para>Enable parsing of multiline commands.  A multiline command
+           is prompted for when the current input line contains open layout
+            contexts (see <xref linkend="ghci-multiline" />).</para>
+         </listitem>
+       </varlistentry>
+
+       <varlistentry>
+         <term>
             <literal>+r</literal>
             <indexterm><primary><literal>+r</literal></primary></indexterm>
             <indexterm><primary>CAFs</primary><secondary>in GHCi</secondary></indexterm>
@@ -2639,7 +2969,7 @@ bar
            top-level expressions to be discarded after each
            evaluation (they are still retained
            <emphasis>during</emphasis> a single evaluation).</para>
-         
+
            <para>This option may help if the evaluated top-level
            expressions are consuming large amounts of space, or if
            you need repeatable performance measurements.</para>
@@ -2682,12 +3012,12 @@ bar
 
       <para>Normal GHC command-line options may also be set using
       <literal>:set</literal>.  For example, to turn on
-      <option>-fglasgow-exts</option>, you would say:</para>
+      <option>-fwarn-missing-signatures</option>, you would say:</para>
 
 <screen>
-Prelude> :set -fglasgow-exts
+Prelude> :set -fwarn-missing-signatures
 </screen>
-      
+
       <para>Any GHC command-line option that is designated as
       <firstterm>dynamic</firstterm> (see the table in <xref
       linkend="flag-reference"/>), may be set using
@@ -2696,7 +3026,7 @@ Prelude> :set -fglasgow-exts
       <indexterm><primary>dynamic</primary><secondary>options</secondary></indexterm>
 
 <screen>
-Prelude> :set -fno-glasgow-exts
+Prelude> :set -fno-warn-incomplete-patterns -XNoMultiParamTypeClasses
 </screen>
 
       <para><xref linkend="flag-reference"/> lists the reverse for each
@@ -2708,7 +3038,74 @@ Prelude> :set -fno-glasgow-exts
       not take effect until the next reload.</para>
       <indexterm><primary>static</primary><secondary>options</secondary></indexterm>
     </sect2>
+
+    <sect2 id="ghci-interactive-options">
+      <title>Setting options for interactive evaluation only</title>
+
+      <para>
+        GHCi actually maintains two sets of options: one set that
+        applies when loading modules, and another set that applies for
+        expressions and commands typed at the prompt.  The
+        <literal>:set</literal> command modifies both, but there is
+        also a <literal>:seti</literal> command (for "set
+        interactive") that affects only the second set.
+      </para>
+
+      <para>
+        The two sets of options can be inspected using the
+        <literal>:set</literal> and <literal>:seti</literal> commands
+        respectively, with no arguments.  For example, in a clean GHCi
+        session we might see something like this:
+      </para>
+
+<screen>
+Prelude> :seti
+base language is: Haskell2010
+with the following modifiers:
+  -XNoMonomorphismRestriction
+  -XNoDatatypeContexts
+  -XNondecreasingIndentation
+  -XExtendedDefaultRules
+GHCi-specific dynamic flag settings:
+other dynamic, non-language, flag settings:
+  -fimplicit-import-qualified
+warning settings:
+</screen>
+      <para>
+        Note that the option <option>-XExtendedDefaultRules</option>
+        is on, because we apply special defaulting rules to
+        expressions typed at the prompt (see <xref
+        linkend="extended-default-rules" />).
+      </para>
+
+      <para>
+        Furthermore, the Monomorphism Restriction is disabled by default in
+        GHCi (see <xref linkend="monomorphism" />).
+      </para>
+
+      <para>
+        It is often useful to change the language options for expressions typed
+        at the prompt only, without having that option apply to loaded modules
+        too.  For example
+<screen>
+:seti -XMonoLocalBinds
+</screen>
+        It would be undesirable if <option>-XMonoLocalBinds</option> were to
+        apply to loaded modules too: that might cause a compilation error, but
+        more commonly it will cause extra recompilation, because GHC will think
+        that it needs to recompile the module because the flags have changed.
+      </para>
+
+      <para>
+        It is therefore good practice if you are setting language
+        options in your <literal>.ghci</literal> file, to use
+        <literal>:seti</literal> rather than <literal>:set</literal>
+        unless you really do want them to apply to all modules you
+        load in GHCi.
+      </para>
+    </sect2>
   </sect1>
+
   <sect1 id="ghci-dot-files">
     <title>The <filename>.ghci</filename> file</title>
     <indexterm><primary><filename>.ghci</filename></primary><secondary>file</secondary>
@@ -2739,16 +3136,24 @@ Prelude> :set -fno-glasgow-exts
 
     <para>The <filename>ghci.conf</filename> file is most useful for
     turning on favourite options (eg. <literal>:set +s</literal>), and
-    defining useful macros.  Placing a <filename>.ghci</filename> file
+    defining useful macros.  Note: when setting language options in
+    this file it is usually desirable to use <literal>:seti</literal>
+    rather than <literal>:set</literal> (see <xref
+    linkend="ghci-interactive-options" />).
+    </para>
+
+    <para>
+    Placing a <filename>.ghci</filename> file
     in a directory with a Haskell project is a useful way to set
     certain project-wide options so you don't have to type them
-    everytime you start GHCi: eg. if your project uses GHC extensions
+    every time you start GHCi: eg. if your project uses multi-parameter 
+    type classes, scoped type variables,
     and CPP, and has source files in three subdirectories A, B and C,
     you might put the following lines in
     <filename>.ghci</filename>:</para>
 
 <screen>
-:set -fglasgow-exts -cpp
+:set -XMultiParamTypeClasses -XScopedTypeVariables -cpp
 :set -iA:B:C
 </screen>
 
@@ -2766,13 +3171,17 @@ Prelude> :set -fno-glasgow-exts
 :def source readFile
 </screen>
 
-    <para>With this macro defined in your <filename>.ghci</filename> 
+    <para>With this macro defined in your <filename>.ghci</filename>
     file, you can use <literal>:source file</literal> to read GHCi
     commands from <literal>file</literal>. You can find (and contribute!-)
     other suggestions for <filename>.ghci</filename> files on this Haskell
     wiki page: <ulink
       url="http://haskell.org/haskellwiki/GHC/GHCi">GHC/GHCi</ulink></para>
 
+       <para>Additionally, any files specified with
+    <literal>-ghci-script</literal> flags will be read after the
+    standard files, allowing the use of custom .ghci files.</para>
+
     <para>Two command-line options control whether the
     startup files files are read:</para>
 
@@ -2789,15 +3198,12 @@ Prelude> :set -fno-glasgow-exts
       </varlistentry>
       <varlistentry>
        <term>
-          <option>-read-dot-ghci</option>
-          <indexterm><primary><option>-read-dot-ghci</option></primary></indexterm>
-        </term>
+         <option>-ghci-script</option>
+         <indexterm><primary><option>-ghci-script</option></primary></indexterm>
+    </term>
        <listitem>
-         <para>Read <filename>./.ghci</filename> and the other
-          startup files (see above).  This is normally the
-         default, but the <option>-read-dot-ghci</option> option may
-         be used to override a previous
-         <option>-ignore-dot-ghci</option> option.</para>
+         <para>Read a specific file after the usual startup files.
+         Maybe be specified repeatedly for multiple inputs.</para>
        </listitem>
       </varlistentry>
     </variablelist>
@@ -2832,7 +3238,7 @@ Prelude> :set -fno-glasgow-exts
 
   <sect1 id="ghci-faq">
     <title>FAQ and Things To Watch Out For</title>
-    
+
     <variablelist>
       <varlistentry>
        <term>The interpreter can't load modules with foreign export
@@ -2921,8 +3327,8 @@ Prelude> :set -fno-glasgow-exts
             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 
+          <para>
+            If you want line-buffered behaviour, as in GHC, you can
             start your program thus:
             <programlisting>
                main = do { hSetBuffering stdout LineBuffering; ... }
@@ -2937,7 +3343,6 @@ Prelude> :set -fno-glasgow-exts
 
 <!-- Emacs stuff:
      ;;; Local Variables: ***
-     ;;; mode: xml ***
      ;;; sgml-parent-document: ("users_guide.xml" "book" "chapter") ***
      ;;; End: ***
  -->