Add -fghci-hist-size=N to set the number of previous steps stored by :trace
[ghc.git] / docs / users_guide / ghci.xml
index d0a8233..c59f4b3 100644 (file)
@@ -38,12 +38,11 @@ Prelude>
 
     <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>
@@ -61,49 +60,12 @@ Prelude>
     The expression may not span several lines - as soon as you press enter,
     GHCi will attempt to evaluate it.</para>
 
-    <para>GHCi also has a multiline mode,
-    <indexterm><primary><literal>:set +m</literal></primary></indexterm>,
-    which is terminated by an empty line:</para>
-
-<screen>
-Prelude> :set +m
-Prelude> let x = 42 in x / 9
-Prelude|
-4.666666666666667
-Prelude>
-</screen>
-
     <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>
-
-    <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>
   </sect1>
 
   <sect1 id="loading-source-files">
@@ -396,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>
@@ -408,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>
@@ -570,6 +538,136 @@ 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>
 
@@ -1001,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">
@@ -1558,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">
@@ -1571,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
@@ -2223,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>
 
@@ -2560,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>
@@ -2735,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
@@ -2768,7 +2950,7 @@ bar
          <listitem>
            <para>Enable parsing of multiline commands.  A multiline command
            is prompted for when the current input line contains open layout
-           contexts.</para>
+            contexts (see <xref linkend="ghci-multiline" />).</para>
          </listitem>
        </varlistentry>
 
@@ -2856,7 +3038,74 @@ Prelude> :set -fno-warn-incomplete-patterns -XNoMultiParamTypeClasses
       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>
@@ -2887,7 +3136,14 @@ Prelude> :set -fno-warn-incomplete-patterns -XNoMultiParamTypeClasses
 
     <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
     every time you start GHCi: eg. if your project uses multi-parameter 
@@ -2922,6 +3178,10 @@ Prelude> :set -fno-warn-incomplete-patterns -XNoMultiParamTypeClasses
     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>
 
@@ -2938,23 +3198,16 @@ Prelude> :set -fno-warn-incomplete-patterns -XNoMultiParamTypeClasses
       </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>
 
-    <para>Additional <filename>.ghci</filename> files can be added
-    through the <option>-ghci-script</option> option. These are
-    loaded after the normal <filename>.ghci</filename> files.</para>
-
   </sect1>
 
   <sect1 id="ghci-obj">