-
Notifications
You must be signed in to change notification settings - Fork 0
/
ghci.xml
3184 lines (2803 loc) · 119 KB
/
ghci.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
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
532
533
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
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
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
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
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
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="iso-8859-1"?>
<chapter id="ghci">
<title>Using GHCi</title>
<indexterm><primary>GHCi</primary></indexterm>
<indexterm><primary>interpreter</primary><see>GHCi</see></indexterm>
<indexterm><primary>interactive</primary><see>GHCi</see></indexterm>
<para>GHCi<footnote>
<para>The ‘i’ stands for “Interactive”</para>
</footnote>
is GHC's interactive environment, in which Haskell expressions can
be interactively evaluated and programs can be interpreted. If
you're familiar with <ulink url="http://www.haskell.org/hugs/">Hugs</ulink><indexterm><primary>Hugs</primary>
</indexterm>, then you'll be right at home with GHCi. However, GHCi
also has support for interactively loading compiled code, as well as
supporting all<footnote><para>except <literal>foreign export</literal>, at the moment</para>
</footnote> the language extensions that GHC provides.
<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>
<sect1 id="ghci-introduction">
<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
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>
<para>There may be a short pause while GHCi loads the prelude and
standard libraries, after which the prompt is shown. As the banner
says, you can type <literal>:?</literal> to see the list of
commands available, and a half line description of each of them.
We'll explain most of these commands as we go along, and there is
complete documentation for all the commands in
<xref linkend="ghci-commands" />.</para>
<para>Haskell expressions can be typed at the prompt:</para>
<indexterm><primary>prompt</primary><secondary>GHCi</secondary>
</indexterm>
<screen>
Prelude> 1+2
3
Prelude> let x = 42 in x / 9
4.666666666666667
Prelude>
</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>
<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>
</sect1>
<sect1 id="loading-source-files">
<title>Loading source files</title>
<para>Suppose we have the following Haskell source code, which we
place in a file <filename>Main.hs</filename>:</para>
<programlisting>
main = print (fac 20)
fac 0 = 1
fac n = n * fac (n-1)
</programlisting>
<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 “Start” 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>
<para>To load a Haskell source file into GHCi, use the
<literal>:load</literal> command:</para>
<indexterm><primary><literal>:load</literal></primary></indexterm>
<screen>
Prelude> :load Main
Compiling Main ( Main.hs, interpreted )
Ok, modules loaded: Main.
*Main>
</screen>
<para>GHCi has loaded the <literal>Main</literal> module, and the
prompt has changed to “<literal>*Main></literal>” to
indicate that the current context for expressions typed at the
prompt is the <literal>Main</literal> module we just loaded (we'll
explain what the <literal>*</literal> means later in <xref
linkend="ghci-scope"/>). So we can now type expressions involving
the functions from <filename>Main.hs</filename>:</para>
<screen>
*Main> fac 17
355687428096000
</screen>
<para>Loading a multi-module program is just as straightforward;
just give the name of the “topmost” 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>
<sect2 id="ghci-modules-filenames">
<title>Modules vs. filenames</title>
<indexterm><primary>modules</primary><secondary>and filenames</secondary></indexterm>
<indexterm><primary>filenames</primary><secondary>of modules</secondary></indexterm>
<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>
<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
linkend="ghci-cmd-line-options"/>)<footnote><para>Note that in
GHCi, and <option>––make</option> mode, the <option>-i</option>
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
linkend="search-path"/>.</para> </footnote></para>
<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>
</sect2>
<sect2>
<title>Making changes and recompilation</title>
<indexterm><primary><literal>:reload</literal></primary></indexterm>
<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
compilation setting (see <xref linkend="recomp"/>).</para>
</sect2>
</sect1>
<sect1 id="ghci-compiled">
<title>Loading compiled code</title>
<indexterm><primary>compiled code</primary><secondary>in GHCi</secondary></indexterm>
<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
copy of the <literal>base</literal> package, which contains the
<literal>Prelude</literal>.</para>
<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>
<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 & C:</para>
<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 )
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 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
<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>
<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>
<screen>
*Main> :! touch D.hs
*Main> :reload
Compiling D ( D.hs, interpreted )
Ok, modules loaded: A, B, C, D.
*Main>
</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>
*Main> :! ghc -c C.hs
*Main> :load A
Compiling D ( D.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>
<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>
*Main> :! ghc -c D.hs
*Main> :reload
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>
*Main> :load A
Compiling B ( B.hs, interpreted )
Compiling A ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.
</screen>
<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
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>
<para>HINT: since GHCi will only use a compiled object file if it
can be sure that the compiled version is up-to-date, a good technique
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 changed modules will be
interpreted, but the rest of the project will remain
compiled.</para>
</sect1>
<sect1 id="interactive-evaluation">
<title>Interactive evaluation at the prompt</title>
<para>When you type an expression at the prompt, GHCi immediately
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>
<sect2 id="ghci-stmts">
<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
Prelude> print x
42
Prelude>
</screen>
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>If <option>-fprint-bind-result</option> is set then
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>
<indexterm><primary><option>-fprint-bind-result</option></primary></indexterm><indexterm><primary><option>-fno-print-bind-result</option></primary></indexterm>.
</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> 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>Note that <literal>let</literal> bindings do not automatically
print the value bound, unlike monadic bindings.</para>
<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>
<para>However, this quickly gets tedious when defining functions
with multiple clauses, or groups of mutually recursive functions,
because the complete definition has to be given on a single line,
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
<literal>:}</literal> are simply merged into a single line for
interpretation. That implies that each such group must form a single
valid command when merged, and that no layout rule is used.
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>
<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-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 <- 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 <interactive>:2:6
instance Enum T -- Defined at <interactive>:2:45
instance Eq T -- Defined at <interactive>:2:30
instance Ord T -- Defined at <interactive>:2:34
instance Show T -- Defined at <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
<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>
<sect2 id="ghci-scope">
<title>What's really in scope at the prompt?</title>
<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>
<screen>Prelude></screen>
<para>Which indicates that everything from the module
<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>
<screen>
Prelude> :load Main.hs
Compiling Main ( Main.hs, interpreted )
*Main>
</screen>
<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
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
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>
<para>To add modules to the scope, use ordinary Haskell
<literal>import</literal> syntax:</para>
<screen>
Prelude> import System.IO
Prelude System.IO> hPutStrLn stdout "hello\n"
hello
Prelude System.IO>
</screen>
<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>
<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
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
"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
set to <literal>Prelude Bar</literal> (GHCi automatically adds
<literal>Prelude</literal> if it isn't present and there aren't
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>
<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>
<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>”.
</para>
<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>
<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>.
</para>
</listitem>
<listitem>
<para>The set of modules that are currently <emphasis>in
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>
</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 “<literal>module M is not
loaded</literal>”.</para>
</sect3>
<sect3 id="ghci-import-qualified">
<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
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>
</sect3>
<sect3>
<title>The <literal>:main</literal> and <literal>:run</literal> commands</title>
<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"]
</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"]
</screen>
</sect3>
</sect2>
<sect2>
<title>The <literal>it</literal> variable</title>
<indexterm><primary><literal>it</literal></primary>
</indexterm>
<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>
<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>
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>
Prelude> id
<interactive>:1:0:
No instance for (Show (a -> a))
arising from use of `print' at <interactive>:1:0-1
Possible fix: add an instance declaration for (Show (a -> a))
In the expression: print it
In a 'do' expression: 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>
<screen>
Prelude> Time.getClockTime
Wed Mar 14 12:23:13 GMT 2001
Prelude> print it
Wed Mar 14 12:23:13 GMT 2001
</screen>
<para>The corresponding translation for an IO-typed
<replaceable>e</replaceable> is
<screen>
it <- <replaceable>e</replaceable>
</screen>
</para>
<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>
<sect2 id="extended-default-rules">
<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: