ghci.xml 119 KB
Newer Older
1
<?xml version="1.0" encoding="iso-8859-1"?>
2
<chapter id="ghci">
3
  <title>Using GHCi</title>
4
  <indexterm><primary>GHCi</primary></indexterm>
5
6
  <indexterm><primary>interpreter</primary><see>GHCi</see></indexterm>
  <indexterm><primary>interactive</primary><see>GHCi</see></indexterm>
daniel.is.fischer's avatar
daniel.is.fischer committed
7

8
9
10
11
12
  <para>GHCi<footnote>
      <para>The &lsquo;i&rsquo; stands for &ldquo;Interactive&rdquo;</para>
    </footnote>
  is GHC's interactive environment, in which Haskell expressions can
  be interactively evaluated and programs can be interpreted.  If
ross's avatar
ross committed
13
  you're familiar with <ulink url="http://www.haskell.org/hugs/">Hugs</ulink><indexterm><primary>Hugs</primary>
14
15
  </indexterm>, then you'll be right at home with GHCi.  However, GHCi
  also has support for interactively loading compiled code, as well as
16
  supporting all<footnote><para>except <literal>foreign export</literal>, at the moment</para>
Simon Marlow's avatar
Simon Marlow committed
17
  </footnote> the language extensions that GHC provides.
18
  <indexterm><primary>FFI</primary><secondary>GHCi support</secondary></indexterm>
Simon Marlow's avatar
Simon Marlow committed
19
20
  <indexterm><primary>Foreign Function
  Interface</primary><secondary>GHCi support</secondary></indexterm>.
Ian Lynagh's avatar
Ian Lynagh committed
21
  GHCi also includes an interactive debugger (see <xref linkend="ghci-debugger"/>).</para>
22

23
  <sect1 id="ghci-introduction">
24
25
26
27
28
29
30
    <title>Introduction to GHCi</title>

    <para>Let's start with an example GHCi session.  You can fire up
    GHCi with the command <literal>ghci</literal>:</para>

<screen>
$ ghci
31
32
33
GHCi, version 6.12.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
34
Loading package base ... linking ... done.
35
Loading package ffi-1.0 ... linking ... done.
daniel.is.fischer's avatar
daniel.is.fischer committed
36
Prelude>
37
38
39
</screen>

    <para>There may be a short pause while GHCi loads the prelude and
40
    standard libraries, after which the prompt is shown. As the banner
41
42
43
44
45
    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>
46
47
48
49
50
51
52
53

    <para>Haskell expressions can be typed at the prompt:</para>
    <indexterm><primary>prompt</primary><secondary>GHCi</secondary>
  </indexterm>

<screen>
Prelude> 1+2
3
54
Prelude> let x = 42 in x / 9
55
4.666666666666667
daniel.is.fischer's avatar
daniel.is.fischer committed
56
Prelude>
57
58
59
</screen>

    <para>GHCi interprets the whole line as an expression to evaluate.
daniel.is.fischer's avatar
daniel.is.fischer committed
60
    The expression may not span several lines - as soon as you press enter,
vivian's avatar
vivian committed
61
62
63
    GHCi will attempt to evaluate it.</para>

    <para>In Haskell, a <literal>let</literal> expression is followed
daniel.is.fischer's avatar
daniel.is.fischer committed
64
65
66
67
    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,
vivian's avatar
vivian committed
68
    as in the above example.</para>
69
70
  </sect1>

71
  <sect1 id="loading-source-files">
72
73
74
    <title>Loading source files</title>

    <para>Suppose we have the following Haskell source code, which we
75
    place in a file <filename>Main.hs</filename>:</para>
76
77
78
79
80
81
82
83

<programlisting>
main = print (fac 20)

fac 0 = 1
fac n = n * fac (n-1)
</programlisting>

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
    <para>You can save <filename>Main.hs</filename> anywhere you like,
    but if you save it somewhere other than the current
    directory<footnote><para>If you started up GHCi from the command
    line then GHCi's current directory is the same as the current
    directory of the shell from which it was started.  If you started
    GHCi from the &ldquo;Start&rdquo; menu in Windows, then the
    current directory is probably something like
    <filename>C:\Documents and Settings\<replaceable>user
    name</replaceable></filename>.</para> </footnote> then we will
    need to change to the right directory in GHCi:</para>

<screen>
Prelude> :cd <replaceable>dir</replaceable>
</screen>

    <para>where <replaceable>dir</replaceable> is the directory (or
    folder) in which you saved <filename>Main.hs</filename>.</para>

102
103
    <para>To load a Haskell source file into GHCi, use the
    <literal>:load</literal> command:</para>
104
    <indexterm><primary><literal>:load</literal></primary></indexterm>
105
106
107
108
109

<screen>
Prelude> :load Main
Compiling Main             ( Main.hs, interpreted )
Ok, modules loaded: Main.
110
*Main>
111
112
113
</screen>

    <para>GHCi has loaded the <literal>Main</literal> module, and the
114
    prompt has changed to &ldquo;<literal>*Main></literal>&rdquo; to
115
    indicate that the current context for expressions typed at the
116
117
    prompt is the <literal>Main</literal> module we just loaded (we'll
    explain what the <literal>*</literal> means later in <xref
118
    linkend="ghci-scope"/>).  So we can now type expressions involving
119
    the functions from <filename>Main.hs</filename>:</para>
120
121

<screen>
122
*Main> fac 17
123
124
125
126
127
128
129
130
131
132
133
134
355687428096000
</screen>

    <para>Loading a multi-module program is just as straightforward;
    just give the name of the &ldquo;topmost&rdquo; module to the
    <literal>:load</literal> command (hint: <literal>:load</literal>
    can be abbreviated to <literal>:l</literal>).  The topmost module
    will normally be <literal>Main</literal>, but it doesn't have to
    be.  GHCi will discover which modules are required, directly or
    indirectly, by the topmost module, and load them all in dependency
    order.</para>

135
    <sect2 id="ghci-modules-filenames">
136
      <title>Modules vs. filenames</title>
137
138
      <indexterm><primary>modules</primary><secondary>and filenames</secondary></indexterm>
      <indexterm><primary>filenames</primary><secondary>of modules</secondary></indexterm>
daniel.is.fischer's avatar
daniel.is.fischer committed
139

140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
      <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
      <literal><replaceable>M</replaceable>.lhs</literal>.  This means
      that for most modules, the module name must match the filename.
      If it doesn't, GHCi won't be able to find it.</para>

      <para>There is one exception to this general rule: when you load
      a program with <literal>:load</literal>, or specify it when you
      invoke <literal>ghci</literal>, you can give a filename rather
      than a module name.  This filename is loaded if it exists, and
      it may contain any module you like.  This is particularly
      convenient if you have several <literal>Main</literal> modules
      in the same directory and you can't call them all
      <filename>Main.hs</filename>.</para>

156
157
158
159
160
161
162
      <para>The search path for finding source files is specified with
      the <option>-i</option> option on the GHCi command line, like
      so:</para>
<screen>ghci -i<replaceable>dir<subscript>1</subscript></replaceable>:...:<replaceable>dir<subscript>n</subscript></replaceable></screen>

      <para>or it can be set using the <literal>:set</literal> command
      from within GHCi (see <xref
163
      linkend="ghci-cmd-line-options"/>)<footnote><para>Note that in
164
      GHCi, and <option>&ndash;&ndash;make</option> mode, the <option>-i</option>
165
166
167
168
      option is used to specify the search path for
      <emphasis>source</emphasis> files, whereas in standard
      batch-compilation mode the <option>-i</option> option is used to
      specify the search path for interface files, see <xref
169
      linkend="search-path"/>.</para> </footnote></para>
170

171
172
173
174
175
176
177
178
179
      <para>One consequence of the way that GHCi follows dependencies
      to find modules to load is that every module must have a source
      file.  The only exception to the rule is modules that come from
      a package, including the <literal>Prelude</literal> and standard
      libraries such as <literal>IO</literal> and
      <literal>Complex</literal>.  If you attempt to load a module for
      which GHCi can't find a source file, even if there are object
      and interface files for the module, you'll get an error
      message.</para>
180
181
182
183
    </sect2>

    <sect2>
      <title>Making changes and recompilation</title>
184
      <indexterm><primary><literal>:reload</literal></primary></indexterm>
185
186
187
188
189
190
191

      <para>If you make some changes to the source code and want GHCi
      to recompile the program, give the <literal>:reload</literal>
      command.  The program will be recompiled as necessary, with GHCi
      doing its best to avoid actually recompiling modules if their
      external dependencies haven't changed.  This is the same
      mechanism we use to avoid re-compiling modules in the batch
192
      compilation setting (see <xref linkend="recomp"/>).</para>
193
194
195
196
197
    </sect2>
  </sect1>

  <sect1 id="ghci-compiled">
    <title>Loading compiled code</title>
198
    <indexterm><primary>compiled code</primary><secondary>in GHCi</secondary></indexterm>
199
200
201
202
203

    <para>When you load a Haskell source module into GHCi, it is
    normally converted to byte-code and run using the interpreter.
    However, interpreted code can also run alongside compiled code in
    GHCi; indeed, normally when GHCi starts, it loads up a compiled
204
205
    copy of the <literal>base</literal> package, which contains the
    <literal>Prelude</literal>.</para>
206
207
208
209
210
211
212
213

    <para>Why should we want to run compiled code?  Well, compiled
    code is roughly 10x faster than interpreted code, but takes about
    2x longer to produce (perhaps longer if optimisation is on).  So
    it pays to compile the parts of a program that aren't changing
    very often, and use the interpreter for the code being actively
    developed.</para>

214
215
216
217
218
219
    <para>When loading up source modules with <literal>:load</literal>,
    GHCi normally looks for any corresponding compiled object files,
    and will use one in preference to interpreting the source if
    possible.  For example, suppose we have a 4-module program
    consisting of modules A, B, C, and D.  Modules B and C both import
    D only, and A imports both B &amp; C:</para>
220
221
222
223
224
225
226
227
228
229
230
231
<screen>
      A
     / \
    B   C
     \ /
      D
</screen>
    <para>We can compile D, then load the whole program, like this:</para>
<screen>
Prelude> :! ghc -c D.hs
Prelude> :load A
Compiling B                ( B.hs, interpreted )
232
Compiling C                ( C.hs, interpreted )
233
234
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
235
*Main>
236
237
</screen>

238
239
240
241
    <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
242
243
    is unchanged since the last compilation.</para>

daniel.is.fischer's avatar
daniel.is.fischer committed
244
    <para>At any time you can use the command
245
246
247
248
249
250
251
252
253
254
255
256
    <literal>:show modules</literal>
    to get a list of the modules currently loaded
    into GHCi:</para>

<screen>
*Main> :show modules
D                ( D.hs, D.o )
C                ( C.hs, interpreted )
B                ( B.hs, interpreted )
A                ( A.hs, interpreted )
*Main></screen>

257
    <para>If we now modify the source of D (or pretend to: using the Unix
258
259
260
261
262
    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>

<screen>
263
264
*Main> :! touch D.hs
*Main> :reload
265
266
Compiling D                ( D.hs, interpreted )
Ok, modules loaded: A, B, C, D.
daniel.is.fischer's avatar
daniel.is.fischer committed
267
*Main>
268
269
270
271
272
273
274
275
276
277
</screen>

    <para>Note that module D was compiled, but in this instance
    because its source hadn't really changed, its interface remained
    the same, and the recompilation checker determined that A, B and C
    didn't need to be recompiled.</para>

    <para>So let's try compiling one of the other modules:</para>

<screen>
278
279
*Main> :! ghc -c C.hs
*Main> :load A
280
281
Compiling D                ( D.hs, interpreted )
Compiling B                ( B.hs, interpreted )
282
Compiling C                ( C.hs, interpreted )
283
284
285
286
287
288
289
290
291
292
293
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
</screen>

    <para>We didn't get the compiled version of C!  What happened?
    Well, in GHCi a compiled module may only depend on other compiled
    modules, and in this case C depends on D, which doesn't have an
    object file, so GHCi also rejected C's object file.  Ok, so let's
    also compile D:</para>

<screen>
294
295
*Main> :! ghc -c D.hs
*Main> :reload
296
297
298
299
300
301
302
303
Ok, modules loaded: A, B, C, D.
</screen>

    <para>Nothing happened!  Here's another lesson: newly compiled
    modules aren't picked up by <literal>:reload</literal>, only
    <literal>:load</literal>:</para>

<screen>
304
*Main> :load A
305
306
307
308
309
Compiling B                ( B.hs, interpreted )
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
</screen>

310
311
312
313
    <para>The automatic loading of object files can sometimes lead to
    confusion, because non-exported top-level definitions of a module
    are only available for use in expressions at the prompt when the
    module is interpreted (see <xref linkend="ghci-scope" />).  For
Simon Marlow's avatar
Simon Marlow committed
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
    this reason, you might sometimes want to force GHCi to load a
    module using the interpreter.  This can be done by prefixing
      a <literal>*</literal> to the module name or filename when
      using <literal>:load</literal>, for example</para>

<screen>
Prelude> :load *A
Compiling A                ( A.hs, interpreted )
*A>
</screen>

<para>When the <literal>*</literal> is used, GHCi ignores any
  pre-compiled object code and interprets the module.  If you have
  already loaded a number of modules as object code and decide that
  you wanted to interpret one of them, instead of re-loading the whole
  set you can use <literal>:add *M</literal> to specify that you want
  <literal>M</literal> to be interpreted (note that this might cause
  other modules to be interpreted too, because compiled modules cannot
  depend on interpreted ones).</para>

<para>To always compile everything to object code and never use the
  interpreter, use the <literal>-fobject-code</literal> option (see
  <xref linkend="ghci-obj" />).</para>
337

338
    <para>HINT: since GHCi will only use a compiled object file if it
Ian Lynagh's avatar
Ian Lynagh committed
339
    can be sure that the compiled version is up-to-date, a good technique
340
    when working on a large program is to occasionally run
341
    <literal>ghc &ndash;&ndash;make</literal> to compile the whole project (say
342
    before you go for lunch :-), then continue working in the
343
    interpreter.  As you modify code, the changed modules will be
344
345
346
347
    interpreted, but the rest of the project will remain
    compiled.</para>
  </sect1>

348
  <sect1 id="interactive-evaluation">
349
350
351
    <title>Interactive evaluation at the prompt</title>

    <para>When you type an expression at the prompt, GHCi immediately
352
353
354
355
356
357
358
359
360
361
    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>
362

363
364
365
366
<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.
367
368
369
370
371
372
<screen>
Prelude> "hello"
"hello"
Prelude> putStrLn "hello"
hello
</screen>
373
374
375
376
377
378
379
380
381
382
383
384
385
386
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"
387
</screen>
388
</para></sect2>
389

390
    <sect2 id="ghci-stmts">
391
392
393
      <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>
daniel.is.fischer's avatar
daniel.is.fischer committed
394

395
396
397
398
      <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>
399

400
401
402
403
404
      <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.
405
<screen>
406
407
408
409
Prelude> x &lt;- return 42
Prelude> print x
42
Prelude>
410
</screen>
411
412
413
414
415
416
      The statement <literal>x &lt;- return 42</literal> means
      &ldquo;execute <literal>return 42</literal> in the
      <literal>IO</literal> monad, and bind the result to
      <literal>x</literal>&rdquo;.  We can then use
      <literal>x</literal> in future statements, for example to print
      it as we did above.</para>
417

418
      <para>If <option>-fprint-bind-result</option> is set then
daniel.is.fischer's avatar
daniel.is.fischer committed
419
      GHCi will print the result of a statement if and only if:
420
421
	<itemizedlist>
	  <listitem>
daniel.is.fischer's avatar
daniel.is.fischer committed
422
	    <para>The statement is not a binding, or it is a monadic binding
423
424
425
426
427
428
429
430
431
	      (<literal>p &lt;- 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>
432
433
      <indexterm><primary><option>-fprint-bind-result</option></primary></indexterm><indexterm><primary><option>-fno-print-bind-result</option></primary></indexterm>.
      </para>
434

435
436
437
438
      <para>Of course, you can also bind normal non-IO expressions
      using the <literal>let</literal>-statement:</para>
<screen>
Prelude> let x = 42
439
Prelude> x
440
441
442
42
Prelude>
</screen>
443
      <para>Another important difference between the two types of binding
444
445
446
447
448
449
450
451
452
453
      is that the monadic bind (<literal>p &lt;- 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>
454
455
456
457

      <para>Note that <literal>let</literal> bindings do not automatically
	print the value bound, unlike monadic bindings.</para>

458
459
460
461
462
463
464
465
      <para>Hint: you can also use <literal>let</literal>-statements
      to define functions at the prompt:</para>
<screen>
Prelude> let add a b = a + b
Prelude> add 1 2
3
Prelude>
</screen>
daniel.is.fischer's avatar
daniel.is.fischer committed
466
        <para>However, this quickly gets tedious when defining functions
467
        with multiple clauses, or groups of mutually recursive functions,
daniel.is.fischer's avatar
daniel.is.fischer committed
468
        because the complete definition has to be given on a single line,
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
        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 }
Prelude> f (+) 0 [1..3]
6
Prelude>
</screen>
      <para>To alleviate this issue, GHCi commands can be split over
      multiple lines, by wrapping them in <literal>:{</literal> and
      <literal>:}</literal> (each on a single line of its own):</para>
<screen>
Prelude> :{
Prelude| let { g op n [] = n
Prelude|     ; g op n (h:t) = h `op` g op n t
Prelude|     }
Prelude| :}
Prelude> g (*) 1 [1..3]
6
</screen>
      <para>Such multiline commands can be used with any GHCi command,
      and the lines between <literal>:{</literal> and
daniel.is.fischer's avatar
daniel.is.fischer committed
490
      <literal>:}</literal> are simply merged into a single line for
491
      interpretation. That implies that each such group must form a single
daniel.is.fischer's avatar
daniel.is.fischer committed
492
      valid command when merged, and that no layout rule is used.
493
494
495
496
      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>

497
498
499
500
501
502
      <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>

503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
      <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>
532

533
    </sect2>
534

535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
    <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>[<emphasis role="bold">New in version 7.4.1</emphasis>] 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>

    </sect2>

661
    <sect2 id="ghci-scope">
daniel.is.fischer's avatar
daniel.is.fischer committed
662
      <title>What's really in scope at the prompt?</title>
663

664
665
666
667
668
      <para>When you type an expression at the prompt, what
      identifiers and types are in scope?  GHCi provides a flexible
      way to control exactly how the context for an expression is
      constructed.  Let's start with the simple cases; when you start
      GHCi the prompt looks like this:</para>
669

670
<screen>Prelude></screen>
671

672
      <para>Which indicates that everything from the module
673
674
675
676
677
678
      <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>
679

680
681
682
683
684
<screen>
Prelude> :load Main.hs
Compiling Main             ( Main.hs, interpreted )
*Main>
</screen>
685

686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
      <para>The new prompt is <literal>*Main</literal>, which
      indicates that we are typing expressions in the context of the
      top-level of the <literal>Main</literal> module.  Everything
      that is in scope at the top-level in the module
      <literal>Main</literal> we just loaded is also in scope at the
      prompt (probably including <literal>Prelude</literal>, as long
      as <literal>Main</literal> doesn't explicitly hide it).</para>

      <para>The syntax
      <literal>*<replaceable>module</replaceable></literal> indicates
      that it is the full top-level scope of
      <replaceable>module</replaceable> that is contributing to the
      scope for expressions typed at the prompt.  Without the
      <literal>*</literal>, just the exports of the module are
      visible.</para>

      <para>We're not limited to a single module: GHCi can combine
      scopes from multiple modules, in any mixture of
      <literal>*</literal> and non-<literal>*</literal> forms.  GHCi
      combines the scopes from all of these modules to form the scope
706
707
708
709
710
      that is in effect at the prompt.</para>

      <para>NOTE: for technical reasons, GHCi can only support the
      <literal>*</literal>-form for modules that are interpreted.
      Compiled modules and package modules can only contribute their
Simon Marlow's avatar
Simon Marlow committed
711
712
713
      exports to the current scope.  To ensure that GHCi loads the
      interpreted version of a module, add the <literal>*</literal>
      when loading the module, e.g. <literal>:load *M</literal>.</para>
714

715
716
      <para>To add modules to the scope, use ordinary Haskell
      <literal>import</literal> syntax:</para>
717

718
<screen>
719
720
Prelude> import System.IO
Prelude System.IO> hPutStrLn stdout "hello\n"
721
hello
722
Prelude System.IO>
723
724
</screen>

725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
      <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 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>
768
769
770
771
772
773
774
775
776
777

<screen>
:module <optional>+|-</optional> <optional>*</optional><replaceable>mod<subscript>1</subscript></replaceable> ... <optional>*</optional><replaceable>mod<subscript>n</subscript></replaceable>
</screen>

      <para>Using the <literal>+</literal> form of the
      <literal>module</literal> commands adds modules to the current
      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
778
779
780
781
782
783
      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
784
785
786
787
788
789
      "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
      <literal>Bar</literal>, then the scope will be set to
      <literal>*Bar</literal> if <literal>Bar</literal> is
      interpreted, or if <literal>Bar</literal> is compiled it will be
Ian Lynagh's avatar
Ian Lynagh committed
790
      set to <literal>Prelude Bar</literal> (GHCi automatically adds
791
      <literal>Prelude</literal> if it isn't present and there aren't
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
      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>
809
810
811
812
813
814
815
816

      <para>With multiple modules in scope, especially multiple
      <literal>*</literal>-form modules, it is likely that name
      clashes will occur.  Haskell specifies that name clashes are
      only reported when an ambiguous identifier is used, and GHCi
      behaves in the same way for expressions typed at the
      prompt.</para>

Ian Lynagh's avatar
Ian Lynagh committed
817
818
819
      <para>
        Hint: GHCi will tab-complete names that are in scope; for
        example, if you run GHCi and type <literal>J&lt;tab&gt;</literal>
Ian Lynagh's avatar
Ian Lynagh committed
820
        then GHCi will expand it to &ldquo;<literal>Just </literal>&rdquo;.
Ian Lynagh's avatar
Ian Lynagh committed
821
822
      </para>

823
824
825
826
827
828
829
830
831
832
833
      <sect3>
        <title><literal>:module</literal> and
        <literal>:load</literal></title>

        <para>It might seem that <literal>:module</literal> and
        <literal>:load</literal> do similar things: you can use both
        to bring a module into scope.  However, there is a clear
        difference.  GHCi is concerned with two sets of modules:</para>

        <itemizedlist>
          <listitem>
834
835
836
837
838
            <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>.
839
840
841
842
            </para>
          </listitem>
          <listitem>
            <para>The set of modules that are currently <emphasis>in
843
844
845
846
847
            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>
848
849
850
851
852
853
854
855
856
857
          </listitem>
        </itemizedlist>

        <para>You cannot add a module to the scope if it is not
          loaded.  This is why trying to
          use <literal>:module</literal> to load a new module results
          in the message &ldquo;<literal>module M is not
            loaded</literal>&rdquo;.</para>
      </sect3>

858
      <sect3 id="ghci-import-qualified">
859
860
861
862
863
	<title>Qualified names</title>

	<para>To make life slightly easier, the GHCi prompt also
        behaves as if there is an implicit <literal>import
        qualified</literal> declaration for every module in every
864
865
        package, and every module currently loaded into GHCi.  This
          behaviour can be disabled with the flag <option>-fno-implicit-import-qualified</option><indexterm><primary><option>-fno-implicit-import-qualified</option></primary></indexterm>.</para>
866
      </sect3>
Ian Lynagh's avatar
Ian Lynagh committed
867
868

      <sect3>
Ian Lynagh's avatar
Ian Lynagh committed
869
        <title>The <literal>:main</literal> and <literal>:run</literal> commands</title>
Ian Lynagh's avatar
Ian Lynagh committed
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891

        <para>
          When a program is compiled and executed, it can use the
          <literal>getArgs</literal> function to access the
          command-line arguments.
          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.
        </para>

        <para>
          Instead, we can use the <literal>:main</literal> command.
          This runs whatever <literal>main</literal> is in scope, with
          any arguments being treated the same as command-line arguments,
          e.g.:
        </para>

<screen>
Prelude> let main = System.Environment.getArgs >>= print
Prelude> :main foo bar
["foo","bar"]
Ian Lynagh's avatar
Ian Lynagh committed
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
</screen>

        <para>
            We can also quote arguments which contains characters like
            spaces, and they are treated like Haskell strings, or we can
            just use Haskell list syntax:
        </para>

<screen>
Prelude> :main foo "bar baz"
["foo","bar baz"]
Prelude> :main ["foo", "bar baz"]
["foo","bar baz"]
</screen>

        <para>
            Finally, other functions can be called, either with the
            <literal>-main-is</literal> flag or the <literal>:run</literal>
            command:
        </para>

<screen>
Prelude> let foo = putStrLn "foo" >> System.Environment.getArgs >>= print
Prelude> let bar = putStrLn "bar" >> System.Environment.getArgs >>= print
Prelude> :set -main-is foo
Prelude> :main foo "bar baz"
foo
["foo","bar baz"]
Prelude> :run bar ["foo", "bar baz"]
bar
["foo","bar baz"]
Ian Lynagh's avatar
Ian Lynagh committed
923
924
925
</screen>

      </sect3>
926
    </sect2>
daniel.is.fischer's avatar
daniel.is.fischer committed
927

928
929
930
931
932

    <sect2>
      <title>The <literal>it</literal> variable</title>
      <indexterm><primary><literal>it</literal></primary>
      </indexterm>
daniel.is.fischer's avatar
daniel.is.fischer committed
933

934
935
936
937
938
939
940
941
942
      <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>
<screen>
Prelude> 1+2
3
Prelude> it * 2
6
</screen>
943
944
945
    <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
daniel.is.fischer's avatar
daniel.is.fischer committed
946
    <replaceable>e</replaceable> turns into
Ian Lynagh's avatar
Ian Lynagh committed
947
948
949
<screen>
let it = <replaceable>e</replaceable>;
print it
950
</screen>
951
952
953
954
955
956
957
    which is then run as an IO-action.</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>

<screen>
Ian Lynagh's avatar
Ian Lynagh committed
958
959
960
961
962
963
964
965
Prelude&gt; id

&lt;interactive&gt;:1:0:
    No instance for (Show (a -&gt; a))
      arising from use of `print' at &lt;interactive&gt;:1:0-1
    Possible fix: add an instance declaration for (Show (a -> a))
    In the expression: print it
    In a 'do' expression: print it
966
967
968
969
</screen>

    <para>The error message contains some clues as to the
    transformation happening internally.</para>
970

971
      <para>If the expression was instead of type <literal>IO a</literal> for
972
973
974
975
976
      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>
<screen>
Prelude> Time.getClockTime
Ian Lynagh's avatar
Ian Lynagh committed
977
Wed Mar 14 12:23:13 GMT 2001
978
979
980
981
Prelude> print it
Wed Mar 14 12:23:13 GMT 2001
</screen>

982
983
      <para>The corresponding translation for an IO-typed
      <replaceable>e</replaceable> is
Ian Lynagh's avatar
Ian Lynagh committed
984
985
<screen>
it &lt;- <replaceable>e</replaceable>
986
987
988
</screen>
      </para>

989
990
991
992
993
      <para>Note that <literal>it</literal> is shadowed by the new
      value each time you evaluate a new expression, and the old value
      of <literal>it</literal> is lost.</para>

    </sect2>
994

995
    <sect2 id="extended-default-rules">
996
997
998
999
1000
      <title>Type defaulting in GHCi</title>
    <indexterm><primary>Type default</primary></indexterm>
    <indexterm><primary><literal>Show</literal> class</primary></indexterm>
      <para>
      Consider this GHCi session: