:set <option> ... set options
:set args <arg> ... set the arguments returned by System.getArgs
:set prog <progname> set the value returned by System.getProgName
-
+ :set prompt <prompt> set the prompt used in GHCi
+
:show modules show the currently loaded modules
:show bindings show the current bindings made at the prompt
+ :ctags [<file>] create tags file for Vi (default: "tags")
+ :etags [<file>] create tags file for Emacs (defauilt: "TAGS")
:type <expr> show the type of <expr>
:kind <type> show the kind of <type>
:undef <cmd> undefine user-defined command :<cmd>
<title>Interactive evaluation at the prompt</title>
<para>When you type an expression at the prompt, GHCi immediately
- evaluates and prints the result. But that's not the whole story:
- if you type something of type <literal>IO a</literal> for some
- <literal>a</literal>, then GHCi <emphasis>executes</emphasis> it
- as an IO-computation, and doesn't attempt to print the
- result:.</para>
+ evaluates and prints the result:
+<screen>
+Prelude> reverse "hello"
+"olleh"
+Prelude> 5+5
+10
+</screen>
+</para>
+<sect2><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
+ <literal>a</literal>, then GHCi <emphasis>executes</emphasis> it
+ as an IO-computation.
<screen>
Prelude> "hello"
"hello"
Prelude> putStrLn "hello"
hello
</screen>
+Furthermore, GHCi will print the result of the I/O action if (and only
+if):
+<itemizedlist>
+ <listitem><para>The result type is an instance of <literal>Show</literal>.</para></listitem>
+ <listitem><para>The result type is not
+ <literal>()</literal>.</para></listitem>
+</itemizedlist>
+For example, remembering that <literal>putStrLn :: String -> IO ()</literal>:
+<screen>
+Prelude> putStrLn "hello"
+hello
+Prelude> do { putStrLn "hello"; return "yes" }
+hello
+"yes"
+</screen>
+</para></sect2>
- <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
-<screen>
- let it = <replaceable>e</replaceable>;
- print it
+ <sect2>
+ <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
+ expressions or statements.</para>
+
+ <para>The syntax of a statement accepted at the GHCi prompt is
+ exactly the same as the syntax of a statement in a Haskell
+ <literal>do</literal> expression. However, there's no monad
+ overloading here: statements typed at the prompt must be in the
+ <literal>IO</literal> monad.
+<screen>
+Prelude> x <- return 42
+42
+Prelude> print x
+42
+Prelude>
</screen>
- which is then run as an IO-action.</para>
+ The statement <literal>x <- return 42</literal> means
+ “execute <literal>return 42</literal> in the
+ <literal>IO</literal> monad, and bind the result to
+ <literal>x</literal>”. We can then use
+ <literal>x</literal> in future statements, for example to print
+ it as we did above.</para>
- <para>Hence, the original expression must have a type which is an
- instance of the <literal>Show</literal> class, or GHCi will
- complain:</para>
+ <para>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
+ (<literal>p <- e</literal>) that binds exactly one
+ variable.</para>
+ </listitem>
+ <listitem>
+ <para>The variable's type is not polymorphic, is not
+ <literal>()</literal>, and is an instance of
+ <literal>Show</literal></para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>Of course, you can also bind normal non-IO expressions
+ using the <literal>let</literal>-statement:</para>
<screen>
-Prelude> id
-No instance for `Show (a -> a)'
-arising from use of `print'
-in a `do' expression pattern binding: print it
+Prelude> let x = 42
+Prelude> x
+42
+Prelude>
+</screen>
+ <para>Another important difference between the two types of binding
+ is that the monadic bind (<literal>p <- e</literal>) is
+ <emphasis>strict</emphasis> (it evaluates <literal>e</literal>),
+ whereas with the <literal>let</literal> form, the expression
+ isn't evaluated immediately:</para>
+<screen>
+Prelude> let x = error "help!"
+Prelude> print x
+*** Exception: help!
+Prelude>
</screen>
- <para>The error message contains some clues as to the
- transformation happening internally.</para>
+ <para>Note that <literal>let</literal> bindings do not automatically
+ print the value bound, unlike monadic bindings.</para>
+
+ <para>Any exceptions raised during the evaluation or execution
+ of the statement are caught and printed by the GHCi command line
+ interface (for more information on exceptions, see the module
+ <literal>Control.Exception</literal> in the libraries
+ documentation).</para>
+
+ <para>Every new binding shadows any existing bindings of the
+ same name, including entities that are in scope in the current
+ module context.</para>
+
+ <para>WARNING: temporary bindings introduced at the prompt only
+ last until the next <literal>:load</literal> or
+ <literal>:reload</literal> command, at which time they will be
+ simply lost. However, they do survive a change of context with
+ <literal>:module</literal>: the temporary bindings just move to
+ the new location.</para>
+
+ <para>HINT: To get a list of the bindings currently in scope, use the
+ <literal>:show bindings</literal> command:</para>
+
+<screen>
+Prelude> :show bindings
+x :: Int
+Prelude></screen>
+
+ <para>HINT: if you turn on the <literal>+t</literal> option,
+ GHCi will show the type of each variable bound by a statement.
+ For example:</para>
+ <indexterm><primary><literal>+t</literal></primary></indexterm>
+<screen>
+Prelude> :set +t
+Prelude> let (x:xs) = [1..]
+x :: Integer
+xs :: [Integer]
+</screen>
+
+ </sect2>
<sect2 id="ghci-scope">
<title>What's really in scope at the prompt?</title>
</sect3>
</sect2>
- <sect2>
- <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
- expressions or statements.</para>
-
- <para>The syntax of a statement accepted at the GHCi prompt is
- exactly the same as the syntax of a statement in a Haskell
- <literal>do</literal> expression. However, there's no monad
- overloading here: statements typed at the prompt must be in the
- <literal>IO</literal> monad.</para>
-
- <para>Here's an example:</para>
-<screen>
-Prelude> x <- return 42
-Prelude> print x
-42
-Prelude>
-</screen>
- <para>The statement <literal>x <- return 42</literal> means
- “execute <literal>return 42</literal> in the
- <literal>IO</literal> monad, and bind the result to
- <literal>x</literal>”. We can then use
- <literal>x</literal> in future statements, for example to print
- it as we did above.</para>
-
- <para>Of course, you can also bind normal non-IO expressions
- using the <literal>let</literal>-statement:</para>
-<screen>
-Prelude> let x = 42
-Prelude> print x
-42
-Prelude>
-</screen>
- <para>An important difference between the two types of binding
- is that the monadic bind (<literal>p <- e</literal>) is
- <emphasis>strict</emphasis> (it evaluates <literal>e</literal>),
- whereas with the <literal>let</literal> form, the expression
- isn't evaluated immediately:</para>
-<screen>
-Prelude> let x = error "help!"
-Prelude> print x
-*** Exception: help!
-Prelude>
-</screen>
- <para>Any exceptions raised during the evaluation or execution
- of the statement are caught and printed by the GHCi command line
- interface (for more information on exceptions, see the module
- <literal>Control.Exception</literal> in the libraries
- documentation).</para>
-
- <para>Every new binding shadows any existing bindings of the
- same name, including entities that are in scope in the current
- module context.</para>
-
- <para>WARNING: temporary bindings introduced at the prompt only
- last until the next <literal>:load</literal> or
- <literal>:reload</literal> command, at which time they will be
- simply lost. However, they do survive a change of context with
- <literal>:module</literal>: the temporary bindings just move to
- the new location.</para>
-
- <para>HINT: To get a list of the bindings currently in scope, use the
- <literal>:show bindings</literal> command:</para>
-
-<screen>
-Prelude> :show bindings
-x :: Int
-Prelude></screen>
-
- <para>HINT: if you turn on the <literal>+t</literal> option,
- GHCi will show the type of each variable bound by a statement.
- For example:</para>
- <indexterm><primary><literal>+t</literal></primary></indexterm>
-<screen>
-Prelude> :set +t
-Prelude> let (x:xs) = [1..]
-x :: Integer
-xs :: [Integer]
-</screen>
-
- </sect2>
<sect2>
<title>The <literal>it</literal> variable</title>
Prelude> it * 2
6
</screen>
-
- <para>This is a result of the translation mentioned earlier,
- namely that an expression <replaceable>e</replaceable> is
- translated to
+ <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
<screen>
let it = <replaceable>e</replaceable>;
print it
</screen>
- before execution, resulting in a binding for
- <literal>it</literal>.</para>
+ which is then run as an IO-action.</para>
- <para>If the expression was of type <literal>IO a</literal> for
+ <para>Hence, the original expression must have a type which is an
+ instance of the <literal>Show</literal> class, or GHCi will
+ complain:</para>
+
+<screen>
+Prelude> id
+No instance for `Show (a -> a)'
+arising from use of `print'
+in a `do' expression pattern binding: print it
+</screen>
+
+ <para>The error message contains some clues as to the
+ transformation happening internally.</para>
+
+ <para>If the expression was instead of type <literal>IO a</literal> for
some <literal>a</literal>, then <literal>it</literal> will be
bound to the result of the <literal>IO</literal> computation,
which is of type <literal>a</literal>. eg.:</para>
[]
</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. If the expression yields a set of
- type constraints that are all from standard classes (<literal>Num</literal>, <literal>Eq</literal> etc.),
- and at least one is either a numeric class <emphasis>or the <literal>Show</literal>,
- <literal>Eq</literal>, or <literal>Ord</literal> class</emphasis>,
- GHCi will try to use one of the <literal>default</literal> types, just as described in the Report.
- The standard defaulting rules require that one of the classes is numeric; the difference here
- is that defaulting is also triggered at least one is <literal>Show</literal>,
- <literal>Eq</literal>, or <literal>Ord</literal>.
+ rules (Section 4.3.4 of the Haskell 98 Report (Revised)) 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
+ <itemizedlist>
+ <listitem><para> The type variable <literal>a</literal>
+ appears in no other constraints </para></listitem>
+ <listitem><para> All the classes <literal>Ci</literal> are standard.</para></listitem>
+ <listitem><para> At least one of the classes <literal>Ci</literal> is
+ numeric.</para></listitem>
+ </itemizedlist>
+ At the GHCi prompt, the second and third rules are relaxed as follows
+ (differences italicised):
+ <itemizedlist>
+ <listitem><para> <emphasis>All</emphasis> of the classes
+ <literal>Ci</literal> are single-parameter type classes.</para></listitem>
+ <listitem><para> At least one of the classes <literal>Ci</literal> is
+ numeric, <emphasis>or is <literal>Show</literal>,
+ <literal>Eq</literal>, or <literal>Ord</literal></emphasis>.</para></listitem>
+ </itemizedlist>
</para>
</sect2>
</sect1>
<varlistentry>
<term>
<literal>:set</literal> <literal>args</literal> <replaceable>arg</replaceable> ...
- <indexterm><primary><literal>:set</literal></primary></indexterm>
+ <indexterm><primary><literal>:set args</literal></primary></indexterm>
</term>
<listitem>
<para>Sets the list of arguments which are returned when the
<varlistentry>
<term>
<literal>:set</literal> <literal>prog</literal> <replaceable>prog</replaceable>
- <indexterm><primary><literal>:set</literal></primary></indexterm>
+ <indexterm><primary><literal>:set prog</literal></primary></indexterm>
</term>
<listitem>
<para>Sets the string to be returned when the program calls
<varlistentry>
<term>
+ <literal>:set</literal> <literal>prompt</literal> <replaceable>prompt</replaceable>
+ </term>
+ <listitem>
+ <para>Sets the string to be used as the prompt in GHCi.
+ 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>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:show bindings</literal>
<indexterm><primary><literal>:show bindings</literal></primary></indexterm>
</term>
<varlistentry>
<term>
+ <literal>:ctags</literal> <optional><replaceable>filename</replaceable></optional>
+ <literal>:etags</literal> <optional><replaceable>filename</replaceable></optional>
+ <indexterm><primary><literal>:etags</literal></primary>
+ </indexterm>
+ <indexterm><primary><literal>:etags</literal></primary>
+ </indexterm>
+ </term>
+ <listitem>
+ <para>Generates a “tags” file for Vi-style editors
+ (<literal>:ctags</literal>) or Emacs-style editors (<literal>etags</literal>). If
+ no filename is specified, the defaulit <filename>tags</filename> or
+ <filename>TAGS</filename> is
+ 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>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:type</literal> <replaceable>expression</replaceable>
<indexterm><primary><literal>:type</literal></primary></indexterm>
</term>