<screen>
$ ghci
-GHCi, version 6.8.1: http://www.haskell.org/ghc/ :? for help
+GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help
+Loading package ghc-prim ... linking ... done.
+Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
+Loading package ffi-1.0 ... linking ... done.
Prelude>
</screen>
</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>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 <- 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">
Prelude IO>
</screen>
- <para>(Note: you can use <literal>import M</literal> as an
- alternative to <literal>:module +M</literal>, and
+ <para>(Note: you can use conventional
+ haskell <literal>import</literal> syntax as
+ well, but this does not support
+ <literal>*</literal> forms).
<literal>:module</literal> can also be shortened to
- <literal>:m</literal>). The full syntax of the
+ <literal>:m</literal>. The full syntax of the
<literal>:module</literal> command is:</para>
<screen>
ghci> reverse []
</programlisting>
What should GHCi do? Strictly speaking, the program is ambiguous. <literal>show (reverse [])</literal>
- (which is what GHCi computes here) has type <literal>Show a => a</literal> and how that displays depends
+ (which is what GHCi computes here) has type <literal>Show a => String</literal> and how that displays depends
on the type <literal>a</literal>. For example:
<programlisting>
- ghci> (reverse []) :: String
+ ghci> reverse ([] :: String)
""
- ghci> (reverse []) :: [Int]
+ ghci> reverse ([] :: [Int])
[]
</programlisting>
However, it is tiresome for the user to have to specify the type, so GHCi extends Haskell's type-defaulting
- 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
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>
<varlistentry>
<term>
+ <literal>:run</literal>
+ <indexterm><primary><literal>:run</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>See <literal>:main</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:set</literal> <optional><replaceable>option</replaceable>...</optional>
<indexterm><primary><literal>:set</literal></primary></indexterm>
</term>
<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.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>+r</literal>
<indexterm><primary><literal>+r</literal></primary></indexterm>
<indexterm><primary>CAFs</primary><secondary>in GHCi</secondary></indexterm>
because this is normally what you want in an interpreter:
output appears as it is generated.
</para>
+ <para>
+ If you want line-buffered behaviour, as in GHC, you can
+ start your program thus:
+ <programlisting>
+ main = do { hSetBuffering stdout LineBuffering; ... }
+ </programlisting>
+ </para>
</listitem>
</varlistentry>
</variablelist>
<!-- Emacs stuff:
;;; Local Variables: ***
- ;;; mode: xml ***
;;; sgml-parent-document: ("users_guide.xml" "book" "chapter") ***
;;; End: ***
-->
projects / ghc-hetmet.git / blobdiff