<indexterm><primary>FFI</primary><secondary>GHCi support</secondary></indexterm>
<indexterm><primary>Foreign Function
Interface</primary><secondary>GHCi support</secondary></indexterm>.
- GHCi also includes an interactive debugger (see <xref linkend="ghci-debugger"/>)..</para>
+ GHCi also includes an interactive debugger (see <xref linkend="ghci-debugger"/>).</para>
<sect1 id="ghci-introduction">
<title>Introduction to GHCi</title>
<screen>
$ ghci
- ___ ___ _
- / _ \ /\ /\/ __(_)
- / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98.
-/ /_\\/ __ / /___| | http://www.haskell.org/ghc/
-\____/\/ /_/\____/|_| Type :? for help.
-
+GHCi, version 6.8.1: http://www.haskell.org/ghc/ :? for help
Loading package base ... linking ... done.
Prelude>
</screen>
<para>There may be a short pause while GHCi loads the prelude and
- standard libraries, after which the prompt is shown. If we follow
- the instructions and type <literal>:?</literal> for help, we
- get:</para>
-
-<screen>
- Commands available from the prompt:
-
- <stmt> evaluate/run <stmt>
- :add <filename> ... add module(s) to the current target set
- :browse [*]<module> display the names defined by <module>
- :cd <dir> change directory to <dir>
- :def <cmd> <expr> define a command :<cmd>
- :edit <file> edit file
- :edit edit last module
- :help, :? display this list of commands
- :info [<name> ...] display information about the given names
- :load <filename> ... load module(s) and their dependents
- :module [+/-] [*]<mod> ... set the context for expression evaluation
- :main [<arguments> ...] run the main function with the given arguments
- :reload reload the current module set
-
- :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
- :set editor <cmd> set the command used for :edit
-
- :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 (default: "TAGS")
- :type <expr> show the type of <expr>
- :kind <type> show the kind of <type>
- :undef <cmd> undefine user-defined command :<cmd>
- :unset <option> ... unset options
- :quit exit GHCi
- :!<command> run the shell command <command>
-
- Options for ':set' and ':unset':
-
- +r revert top-level expressions after each evaluation
- +s print timing/memory stats after each evaluation
- +t print type after evaluation
- -<flags> most GHC command line flags can also be set here
- (eg. -v2, -fglasgow-exts, etc.)
-</screen>
+ 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
<screen>
Prelude> :! ghc -c D.hs
Prelude> :load A
-Skipping D ( D.hs, D.o )
-Compiling C ( C.hs, interpreted )
Compiling B ( B.hs, interpreted )
+Compiling C ( C.hs, interpreted )
Compiling A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
*Main>
</screen>
- <para>In the messages from the compiler, we see that it skipped D,
- and used the object file <filename>D.o</filename>. The message
- <literal>Skipping</literal> <replaceable>module</replaceable>
- indicates that compilation for <replaceable>module</replaceable>
- isn't necessary, because the source and everything it depends on
+ <para>In the messages from the compiler, we see that there is no line
+ for <literal>D</literal>. This is because
+ it isn't necessary to compile <literal>D</literal>,
+ because the source and everything it depends on
is unchanged since the last compilation.</para>
<para>At any time you can use the command
A ( A.hs, interpreted )
*Main></screen>
- <para>If we now modify the source of D (or pretend to: using Unix
+ <para>If we now modify the source of D (or pretend to: using the Unix
command <literal>touch</literal> on the source file is handy for
this), the compiler will no longer be able to use the object file,
because it might be out of date:</para>
*Main> :! touch D.hs
*Main> :reload
Compiling D ( D.hs, interpreted )
-Skipping C ( C.hs, interpreted )
-Skipping B ( B.hs, interpreted )
-Skipping A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
*Main>
</screen>
*Main> :! ghc -c C.hs
*Main> :load A
Compiling D ( D.hs, interpreted )
-Compiling C ( C.hs, interpreted )
Compiling B ( B.hs, interpreted )
+Compiling C ( C.hs, interpreted )
Compiling A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
</screen>
<screen>
*Main> :load A
-Skipping D ( D.hs, D.o )
-Skipping C ( C.hs, C.o )
Compiling B ( B.hs, interpreted )
Compiling A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
when working on a large program is to occasionally run
<literal>ghc ––make</literal> to compile the whole project (say
before you go for lunch :-), then continue working in the
- interpreter. As you modify code, the new modules will be
+ interpreter. As you modify code, the changed modules will be
interpreted, but the rest of the project will remain
compiled.</para>
Prelude IO>
</screen>
- <para>(Note: <literal>:module</literal> can be shortened to
+ <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>
Hint: GHCi will tab-complete names that are in scope; for
example, if you run GHCi and type <literal>J<tab></literal>
- then GHCi will expand it to <literal>Just </literal>.
+ then GHCi will expand it to “<literal>Just </literal>”.
</para>
<sect3>
</listitem>
</orderedlist>
At the GHCi prompt, or with GHC if the
- <literal>-fextended-default-rules</literal> flag is given,
+ <literal>-XExtendedDefaultRules</literal> flag is given,
the following additional differences apply:
<itemizedlist>
<listitem>
instance that returns <literal>IO a</literal>.
However, it is only able to return
<literal>undefined</literal>
- (the reason for the instance having this type is to not require
- extensions to the class system), so if the type defaults to
+ (the reason for the instance having this type is so that printf
+ doesn't require extensions to the class system), so if the type defaults to
<literal>Integer</literal> then ghci gives an error when running a
printf.
</para>
<para>The debugger provides the following:
<itemizedlist>
<listitem>
- <para>The abilty to set a <firstterm>breakpoint</firstterm> on a
+ <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
execution and returns to the prompt, where you can inspect the
<para>The execution continued at the point it previously stopped, and has
now stopped at the breakpoint for a second time.</para>
- <sect3 id="setting-breakpoings">
+ <sect3 id="setting-breakpoints">
<title>Setting breakpoints</title>
<para>Breakpoints can be set in various ways. Perhaps the easiest way to
<title>Listing and deleting breakpoints</title>
<para>The list of breakpoints currently enabled can be displayed using
- <literal>:show breaks</literal></para>:
+ <literal>:show breaks</literal>:</para>
<screen>
*Main> :show breaks
[0] Main qsort.hs:1:11-12
<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. The concept is simple: single-stepping enables all the
- breakpoints in the program and executes until the next breakpoint is
- reached, at which point you can single-step again, or continue
- normally. For example:</para>
+ 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>:stepover</literal> to step over function
+ applications, which of course are executed all the same.
+ For example:</para>
<screen>
*Main> :step main
</screen>
<para>The command <literal>:step
- <replaceable>expr</replaceable></literal> begins the evaluation of
+ <replaceable>expr</replaceable></literal> begins the evaluation of
<replaceable>expr</replaceable> in single-stepping mode. If
<replaceable>expr</replaceable> is ommitted, then it single-steps from
- the current breakpoint.</para>
-
+ the current breakpoint. <literal>:stepover</literal>
+ works similarly.</para>
+
+ <para>In the current version of the debugger, <literal>:stepover</literal>
+ is limited to work locally in the lexical sense, that is in the context
+ of the current expression body.
+ When you run to the end of the expression, <literal>:stepover</literal>
+ stops working and switches to behave like regular <literal>:step</literal>.
+ This means
+ that it will fail to step over the last function application. As a result,
+ currently <literal>:stepover</literal> works great for monadic code, but
+ interacts less perfectly with pure code. For example, if stopped at the
+ line 2, on the entire expression
+ <literal>qsort left ++ [a] ++ qsort right</literal>:</para>
+<screen>
+... [qsort2.hs:2:15-46] *Main> :step
+Stopped at qsort2.hs:2:15-46
+
+... [qsort2.hs:2:15-46] *Main> :list
+2 qsort (a:as) = qsort left ++ [a] ++ qsort right
+</screen>
+
+ <para> The first <literal>:stepover</literal> will step over the first
+ <literal>qsort</literal> recursive call, as expected. The second one
+ will step over the evaluation of <literal>[a]</literal>, again as
+ expected. However, the third one has lexically <quote>run out</quote>
+ of the current expression, and will behave like regular
+ <literal>:step</literal>, performing one step of lazy evaluation and
+ stopping at the next breakpoint. In this case it is indeed the second
+ recursive application of <literal>qsort</literal>.</para>
+<screen>
+[qsort2.hs:2:36-46] *Main> :stepover
+Warning: no more breakpoints in this function body, switching to :step
+Stopped at qsort2.hs:(1,0)-(3,55)
+
+[qsort2.hs:2:36-46] *Main> :list
+_result :: [a]
+1 qsort [] = []
+2 qsort (a:as) = qsort left ++ [a] ++ qsort right
+3 where (left,right) = (filter (<=a) as, filter (>a) as)
+</screen>
<para>The <literal>:list</literal> command is particularly useful when
- single-stepping, to see where you currently are:</para>
+ single-stepping, to see where you currently are, as just shown
+ in the above example.</para>
<screen>
[qsort.hs:5:7-47] *Main> :list
have no context information attached to them. Finding which
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>.</para>
+ <literal>Debug.Trace.trace</literal>, or compiling with
+ profiling and using <literal>+RTS -xc</literal> (see <xref
+ linkend="prof-time-options" />).</para>
<para>The GHCi debugger offers a way to hopefully shed some light on
these errors quickly and without modifying or recompiling the source
CAF (e.g. main), stop at a breakpoint, and ask for the value of the
CAF at the prompt again.</para>
</listitem>
+ <listitem> <literal>:stepover</literal> only works lexically locally, in the
+ body of the current expression. As a result, it can be rather impredictable
+ when used in pure functional code, as opposed to monadic code.
+ </listitem>
<listitem><para>
Implicit parameters (see <xref linkend="implicit-parameters"/>) are only available
- at the scope of a breakpoint if there is a explicit type signature.
+ at the scope of a breakpoint if there is an explicit type signature.
</para>
</listitem>
</itemizedlist>
<para>Most of the command-line options accepted by GHC (see <xref
linkend="using-ghc"/>) also make sense in interactive mode. The ones
- that don't make sense are mostly obvious; for example, GHCi
- doesn't generate interface files, so options related to interface
- file generation won't have any effect.</para>
+ that don't make sense are mostly obvious.</para>
<sect2>
<title>Packages</title>
<screen>
$ ghci -package readline
- ___ ___ _
- / _ \ /\ /\/ __(_)
- / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98.
-/ /_\\/ __ / /___| | http://www.haskell.org/ghc/
-\____/\/ /_/\____/|_| Type :? for help.
-
+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>
<variablelist>
<varlistentry>
<term>
+ <literal>:abandon</literal>
+ <indexterm><primary><literal>:abandon</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Abandons the current evaluation (only available when stopped at
+ a breakpoint).</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:add</literal> <replaceable>module</replaceable> ...
<indexterm><primary><literal>:add</literal></primary></indexterm>
</term>
<varlistentry>
<term>
- <literal>:breakpoint</literal> <replaceable>list|add|continue|del|stop|step</replaceable> ...
- <indexterm><primary><literal>:breakpoint</literal></primary></indexterm>
+ <literal>:back</literal>
+ <indexterm><primary><literal>:back</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Travel back one step in the history. See <xref
+ linkend="tracing" />. See also:
+ <literal>:trace</literal>, <literal>:history</literal>,
+ <literal>:forward</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>:break [<replaceable>identifier</replaceable> |
+ [<replaceable>module</replaceable>] <replaceable>line</replaceable>
+ [<replaceable>column</replaceable>]]</literal>
</term>
+ <indexterm><primary><literal>:break</literal></primary></indexterm>
<listitem>
- <para>Permits to add, delete or list the breakpoints in a debugging session.
- </para>
+ <para>Set a breakpoint on the specified function or line and
+ column. See <xref linkend="setting-breakpoints" />.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
+ <literal>:cmd</literal> <replaceable>expr</replaceable>
+ <indexterm><primary><literal>:cmd</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Executes <replaceable>expr</replaceable> as a computation of
+ type <literal>IO String</literal>, and then executes the resulting
+ string as a list of GHCi commands. Multiple commands are separated
+ by newlines. The <literal>:cmd</literal> command is useful with
+ <literal>:def</literal> and <literal>:set stop</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:continue</literal>
<indexterm><primary><literal>:continue</literal></primary></indexterm>
</term>
- <listitem><para>Shortcut to <literal>:breakpoint continue</literal></para>
+ <listitem><para>Continue the current evaluation, when stopped at a
+ breakpoint.</para>
+ </listitem>
+ </varlistentry>
+
+ <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>:delete * | <replaceable>num</replaceable> ...</literal>
+ <indexterm><primary><literal>:delete</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Delete one or more breakpoints by number (use <literal>:show
+ breaks</literal> to see the number of each breakpoint). The
+ <literal>*</literal> form deletes all the breakpoints.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:edit <optional><replaceable>file</replaceable></optional></literal>
<indexterm><primary><literal>:edit</literal></primary></indexterm>
</term>
<varlistentry>
<term>
+ <literal>:etags</literal>
+ </term>
+ <listitem>
+ <para>See <literal>:ctags</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>:force <replaceable>identifier</replaceable> ...</literal>
+ <indexterm><primary><literal>:force</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Prints the value of <replaceable>identifier</replaceable> in
+ the same way as <literal>:print</literal>. Unlike
+ <literal>:print</literal>, <literal>:force</literal> evaluates each
+ thunk that it encounters while traversing the value. This may
+ cause exceptions or infinite loops, or further breakpoints (which
+ are ignored, but displayed).</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>:forward</literal>
+ <indexterm><primary><literal>:forward</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Move forward in the history. See <xref
+ linkend="tracing" />. See also:
+ <literal>:trace</literal>, <literal>:history</literal>,
+ <literal>:back</literal>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:help</literal>
<indexterm><primary><literal>:help</literal></primary></indexterm>
</term>
<varlistentry>
<term>
+ <literal>:history [<replaceable>num</replaceable>]</literal>
+ <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>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:info</literal> <replaceable>name</replaceable> ...
<indexterm><primary><literal>:info</literal></primary></indexterm>
</term>
will be printed. If <replaceable>name</replaceable> has
been loaded from a source file, then GHCi will also display
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>,
+ and (b) all the other things mentioned in the instance
+ 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>
+ <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>
</listitem>
</varlistentry>
However, we cannot simply pass the arguments to the
<literal>main</literal> function while we are testing in ghci,
as the <literal>main</literal> function doesn't take its
- directly.
+ arguments directly.
</para>
<para>
<literal>:module <optional>+|-</optional> <optional>*</optional><replaceable>mod<subscript>1</subscript></replaceable> ... <optional>*</optional><replaceable>mod<subscript>n</subscript></replaceable></literal>
<indexterm><primary><literal>:module</literal></primary></indexterm>
</term>
+ <term>
+ <literal>import <replaceable>mod</replaceable></literal>
+ </term>
<listitem>
<para>Sets or modifies the current context for statements
- typed at the prompt. See <xref linkend="ghci-scope"/> for
+ typed at the prompt. The form <literal>import
+ <replaceable>mod</replaceable></literal> is equivalent to
+ <literal>:module +<replaceable>mod</replaceable></literal>.
+ See <xref linkend="ghci-scope"/> for
more details.</para>
</listitem>
</varlistentry>
<indexterm><primary><literal>:print</literal></primary></indexterm>
</term>
<listitem>
- <para> Prints a semievaluated value without forcing its evaluation.
- <literal>:print </literal> works just like <literal>:sprint</literal> but additionally,
- <literal>:print</literal> binds the unevaluated parts -called
- <quote>suspensions</quote>-
- to names which you can play with. For example:
-<screen>
-Prelude> let li = map Just [1..5]
-Prelude> :sp li
-li - _
-Prelude> :p li
-li - (_t1::[Maybe Integer])
-Prelude> head li
-Just 1
-Prelude> :sp li
-li - Just 1 : _
-Prelude> :p li
-li - Just 1 : (_t2::[Maybe Integer])
-Prelude> last li
-Just 5
-Prelude> :sp li
-li - [Just 1,_,_,_,Just 5]
-Prelude> :p li
-li - [Just 1,(_t3::Maybe Integer),(_t4::Maybe Integer),(_t5::Maybe Integer),Just 4]
-Prelude> _t4
-Just 3
-Prelude> :p li
-li - [Just 1,(_t6::Maybe Integer),Just 3,(_t7::Maybe Integer),Just 4]
-</screen>
- The example uses <literal>:print</literal> and <literal>:sprint</literal>
- to help us observe how the <literal>li</literal> variable is evaluated progressively as we operate
- with it. Note for instance how <quote>last</quote> traverses all the elements of
- the list to compute its result, but without evaluating the individual elements.
- </para>
+ <para>Prints a value without forcing its evaluation.
+ <literal>:print</literal> may be used on values whose types are
+ unknown or partially known, which might be the case for local
+ variables with polymorphic types at a breakpoint. While inspecting
+ the runtime value, <literal>:print</literal> attempts to
+ reconstruct the type of the value, and will elaborate the type in
+ GHCi's environment if possible. If any unevaluated components
+ (thunks) are encountered, then <literal>:print</literal> binds
+ a fresh variable with a name beginning with <literal>_t</literal>
+ to each thunk. See <xref linkend="breakpoints" /> for more
+ information. See also the <literal>:sprint</literal> command,
+ which works like <literal>:print</literal> but does not bind new
+ variables.</para>
</listitem>
</varlistentry>
<indexterm><primary><literal>:quit</literal></primary></indexterm>
</term>
<listitem>
- <para>Quits GHCi. You can also quit by typing a control-D
+ <para>Quits GHCi. You can also quit by typing control-D
at the prompt.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
+ <literal>:set</literal> <literal>stop</literal>
+ [<replaceable>num</replaceable>] <replaceable>cmd</replaceable>
+ </term>
+ <listitem>
+ <para>Set a command to be executed when a breakpoint is hit, or a new
+ item in the history is selected. The most common use of
+ <literal>:set stop</literal> is to display the source code at the
+ current location, e.g. <literal>:set stop :list</literal>.</para>
+
+ <para>If a number is given before the command, then the commands are
+ run when the specified breakpoint (only) is hit. This can be quite
+ useful: for example, <literal>:set stop 1 :continue</literal>
+ effectively disables breakpoint 1, by running
+ <literal>:continue</literal> whenever it is hit (although GHCi will
+ still emit a message to say the breakpoint was hit). What's more,
+ with cunning use of <literal>:def</literal> and
+ <literal>:cmd</literal> you can use <literal>:set stop</literal> to
+ implement conditional breakpoints:</para>
+<screen>
+*Main> :def cond \expr -> return (":cmd if (" ++ expr ++ ") then return \"\" else return \":continue\"")
+*Main> :set stop 0 :cond (x < 3)
+</screen>
+ <para>Ignoring breakpoints for a specified number of iterations is
+ also possible using similar techniques.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:show bindings</literal>
<indexterm><primary><literal>:show bindings</literal></primary></indexterm>
</term>
<varlistentry>
<term>
+ <literal>:show breaks</literal>
+ <indexterm><primary><literal>:show breaks</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>List the active breakpoints.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>:show context</literal>
+ <indexterm><primary><literal>:show context</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>List the active evaluations that are stopped at breakpoints.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<literal>:show modules</literal>
<indexterm><primary><literal>:show modules</literal></primary></indexterm>
</term>
<listitem>
- <para>Show the list of modules currently load.</para>
+ <para>Show the list of modules currently loaded.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>:show [args|prog|prompt|editor|stop]</literal>
+ <indexterm><primary><literal>:show</literal></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Displays the specified setting (see
+ <literal>:set</literal>).</para>
</listitem>
</varlistentry>
+
<varlistentry>
<term>
<literal>:sprint</literal>
<indexterm><primary><literal>:sprint</literal></primary></indexterm>
</term>
<listitem>
- <para>Prints a semievaluated value without forcing its evaluation.
- <literal>:sprint</literal> and its sibling <literal>:print</literal>
- are very useful to observe how lazy evaluation works in your code. For example:
-<screen>
-Prelude> let li = map Just [1..5]
-Prelude> :sp li
-li - _
-Prelude> head li
-Just 1
-Prelude> :sp li
-li - Just 1 : _
-Prelude> last li
-Just 5
-Prelude> :sp li
-li - [Just 1,_,_,_,Just 5]
-</screen>
- The example uses <literal>:sprint</literal> to help us observe how the <literal>li</literal> variable is evaluated progressively as we operate
- with it. Note for instance how <quote>last</quote> traverses all the elements of
- the list to compute its result, but without evaluating the individual elements.
- </para>
+ <para>Prints a value without forcing its evaluation.
+ <literal>:sprint</literal> is similar to <literal>:print</literal>,
+ with the difference that unevaluated subterms are not bound to new
+ variables, they are simply denoted by ‘_’.</para>
</listitem>
</varlistentry>
+
<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>
+ <literal>:step [<replaceable>expr</replaceable>]</literal>
+ <indexterm><primary><literal>:step</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>
+ <para>Single-step from the last breakpoint. With an expression
+ argument, begins evaluation of the expression with a
+ single-step.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
- <literal>:type</literal> <replaceable>expression</replaceable>
- <indexterm><primary><literal>:type</literal></primary></indexterm>
+ <literal>:trace [<replaceable>expr</replaceable>]</literal>
+ <indexterm><primary><literal>:trace</literal></primary></indexterm>
</term>
<listitem>
- <para>Infers and prints the type of
- <replaceable>expression</replaceable>, including explicit
- forall quantifiers for polymorphic types. The monomorphism
- restriction is <emphasis>not</emphasis> applied to the
- expression during type inference.</para>
+ <para>Evaluates the given expression (or from the last breakpoint if
+ no expression is given), and additionally logs the evaluation
+ steps for later inspection using <literal>:history</literal>. See
+ <xref linkend="tracing" />.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
- <literal>:kind</literal> <replaceable>type</replaceable>
- <indexterm><primary><literal>:kind</literal></primary></indexterm>
+ <literal>:type</literal> <replaceable>expression</replaceable>
+ <indexterm><primary><literal>:type</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>
+ <para>Infers and prints the type of
+ <replaceable>expression</replaceable>, including explicit
+ forall quantifiers for polymorphic types. The monomorphism
+ restriction is <emphasis>not</emphasis> applied to the
+ expression during type inference.</para>
</listitem>
</varlistentry>
<para>The <literal>:set</literal> command sets two types of
options: GHCi options, which begin with
- ‘<literal>+</literal>” and “command-line”
+ ‘<literal>+</literal>’, and “command-line”
options, which begin with ‘-’. </para>
<para>NOTE: at the moment, the <literal>:set</literal> command
<indexterm><primary>startup</primary><secondary>files, GHCi</secondary>
</indexterm>
- <para>When it starts, GHCi always reads and executes commands from
- <filename>$HOME/.ghci</filename>, followed by
- <filename>./.ghci</filename>.</para>
+ <para>When it starts, unless the <literal>-ignore-dot-ghci</literal>
+ flag is given, GHCi reads and executes commands from
+ <filename>./.ghci</filename>, followed by
+ <filename>$HOME/.ghci</filename>.</para>
<para>The <filename>.ghci</filename> in your home directory is
most useful for turning on favourite options (eg. <literal>:set
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 and CPP, and has source files in three
- subdirectories A B and C, you might put the following lines in
+ subdirectories A, B and C, you might put the following lines in
<filename>.ghci</filename>:</para>
<screen>
<term>I can't use Control-C to interrupt computations in
GHCi on Windows.</term>
<listitem>
- <para>See <xref linkend="ghci-windows"/></para>
+ <para>See <xref linkend="ghci-windows"/>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>The default buffering mode is different in GHCi to GHC.</term>
+ <listitem>
+ <para>
+ In GHC, the stdout handle is line-buffered by default.
+ However, in GHCi we turn off the buffering on stdout,
+ because this is normally what you want in an interpreter:
+ output appears as it is generated.
+ </para>
</listitem>
</varlistentry>
</variablelist>
projects / ghc-hetmet.git / blobdiff