97e02cf7f4d60b9b1ddbed7b77b6a356b5ed7be7
[ghc-hetmet.git] / ghc / docs / users_guide / glasgow_exts.sgml
1 <para>
2 <indexterm><primary>language, GHC</primary></indexterm>
3 <indexterm><primary>extensions, GHC</primary></indexterm>
4 As with all known Haskell systems, GHC implements some extensions to
5 the language.  To use them, you'll need to give a <option>-fglasgow-exts</option>
6 <indexterm><primary>-fglasgow-exts option</primary></indexterm> option.
7 </para>
8
9 <para>
10 Virtually all of the Glasgow extensions serve to give you access to
11 the underlying facilities with which we implement Haskell.  Thus, you
12 can get at the Raw Iron, if you are willing to write some non-standard
13 code at a more primitive level.  You need not be &ldquo;stuck&rdquo; on
14 performance because of the implementation costs of Haskell's
15 &ldquo;high-level&rdquo; features&mdash;you can always code &ldquo;under&rdquo; them.  In an extreme case, you can write all your time-critical code in C, and then just glue it together with Haskell!
16 </para>
17
18 <para>
19 Executive summary of our extensions:
20 </para>
21
22   <variablelist>
23
24     <varlistentry>
25       <term>Unboxed types and primitive operations:</Term>
26       <listitem>
27         <para>You can get right down to the raw machine types and
28         operations; included in this are &ldquo;primitive
29         arrays&rdquo; (direct access to Big Wads of Bytes).  Please
30         see <XRef LinkEnd="glasgow-unboxed"> and following.</para>
31       </listitem>
32     </varlistentry>
33
34     <varlistentry>
35       <term>Type system extensions:</term>
36       <listitem>
37         <para> GHC supports a large number of extensions to Haskell's
38         type system.  Specifically:</para>
39
40         <variablelist>
41           <varlistentry>
42             <term>Multi-parameter type classes:</term>
43             <listitem>
44               <para><xref LinkEnd="multi-param-type-classes"></para>
45             </listitem>
46           </varlistentry>
47
48           <varlistentry>
49             <term>Functional dependencies:</term>
50             <listitem>
51               <para><xref LinkEnd="functional-dependencies"></para>
52             </listitem>
53           </varlistentry>
54
55           <varlistentry>
56             <term>Implicit parameters:</term>
57             <listitem>
58               <para><xref LinkEnd="implicit-parameters"></para>
59             </listitem>
60           </varlistentry>
61
62           <varlistentry>
63             <term>Local universal quantification:</term>
64             <listitem>
65               <para><xref LinkEnd="universal-quantification"></para>
66             </listitem>
67           </varlistentry>
68
69           <varlistentry>
70             <term>Extistentially quantification in data types:</term>
71             <listitem>
72               <para><xref LinkEnd="existential-quantification"></para>
73             </listitem>
74           </varlistentry>
75
76           <varlistentry>
77             <term>Scoped type variables:</term>
78             <listitem>
79               <para>Scoped type variables enable the programmer to
80               supply type signatures for some nested declarations,
81               where this would not be legal in Haskell 98.  Details in
82               <xref LinkEnd="scoped-type-variables">.</para>
83             </listitem>
84           </varlistentry>
85         </variablelist>
86       </listitem>
87     </varlistentry>
88
89     <varlistentry>
90       <term>Pattern guards</term>
91       <listitem>
92         <para>Instead of being a boolean expression, a guard is a list
93         of qualifiers, exactly as in a list comprehension. See <xref
94         LinkEnd="pattern-guards">.</para>
95       </listitem>
96     </varlistentry>
97
98     <varlistentry>
99       <term>Data types with no constructors</term>
100       <listitem>
101         <para>See <xref LinkEnd="nullary-types">.</para>
102       </listitem>
103     </varlistentry>
104
105     <varlistentry>
106       <term>Parallel list comprehensions</term>
107       <listitem>
108         <para>An extension to the list comprehension syntax to support
109         <literal>zipWith</literal>-like functionality.  See <xref
110         linkend="parallel-list-comprehensions">.</para>
111       </listitem>
112     </varlistentry>
113
114     <varlistentry>
115       <term>Foreign calling:</term>
116       <listitem>
117         <para>Just what it sounds like.  We provide
118         <emphasis>lots</emphasis> of rope that you can dangle around
119         your neck.  Please see <xref LinkEnd="ffi">.</para>
120       </listitem>
121     </varlistentry>
122
123     <varlistentry>
124       <term>Pragmas</term>
125       <listitem>
126         <para>Pragmas are special instructions to the compiler placed
127         in the source file.  The pragmas GHC supports are described in
128         <xref LinkEnd="pragmas">.</para>
129       </listitem>
130     </varlistentry>
131
132     <varlistentry>
133       <term>Rewrite rules:</term>
134       <listitem>
135         <para>The programmer can specify rewrite rules as part of the
136         source program (in a pragma).  GHC applies these rewrite rules
137         wherever it can.  Details in <xref
138         LinkEnd="rewrite-rules">.</para>
139       </listitem>
140     </varlistentry>
141
142     <varlistentry>
143       <term>Generic classes:</term>
144       <listitem>
145         <para>Generic class declarations allow you to define a class
146         whose methods say how to work over an arbitrary data type.
147         Then it's really easy to make any new type into an instance of
148         the class.  This generalises the rather ad-hoc "deriving"
149         feature of Haskell 98.  Details in <xref
150         LinkEnd="generic-classes">.</para>
151       </listitem>
152     </varlistentry>
153   </variablelist>
154
155 <para>
156 Before you get too carried away working at the lowest level (e.g.,
157 sloshing <literal>MutableByteArray&num;</literal>s around your
158 program), you may wish to check if there are libraries that provide a
159 &ldquo;Haskellised veneer&rdquo; over the features you want.  See
160 <xref linkend="book-hslibs">.
161 </para>
162
163   <sect1 id="options-language">
164     <title>Language options</title>
165
166     <indexterm><primary>language</primary><secondary>option</secondary>
167     </indexterm>
168     <indexterm><primary>options</primary><secondary>language</secondary>
169     </indexterm>
170     <indexterm><primary>extensions</primary><secondary>options controlling</secondary>
171     </indexterm>
172
173     <para> These flags control what variation of the language are
174     permitted.  Leaving out all of them gives you standard Haskell
175     98.</para>
176
177     <variablelist>
178
179       <varlistentry>
180         <term><option>-fglasgow-exts</option>:</term>
181         <indexterm><primary><option>-fglasgow-exts</option></primary></indexterm>
182         <listitem>
183           <para>This simultaneously enables all of the extensions to
184           Haskell 98 described in <xref
185           linkend="ghc-language-features">, except where otherwise
186           noted. </para>
187         </listitem>
188       </varlistentry>
189
190       <varlistentry>
191         <term><option>-fno-monomorphism-restriction</option>:</term>
192         <indexterm><primary><option>-fno-monomorphism-restriction</option></primary></indexterm>
193         <listitem>
194           <para> Switch off the Haskell 98 monomorphism restriction.
195           Independent of the <option>-fglasgow-exts</option>
196           flag. </para>
197         </listitem>
198       </varlistentry>
199
200       <varlistentry>
201         <term><option>-fallow-overlapping-instances</option></term>
202         <term><option>-fallow-undecidable-instances</option></term>
203         <term><option>-fcontext-stack</option></term>
204         <indexterm><primary><option>-fallow-overlapping-instances</option></primary></indexterm>
205         <indexterm><primary><option>-fallow-undecidable-instances</option></primary></indexterm>
206         <indexterm><primary><option>-fcontext-stack</option></primary></indexterm>
207         <listitem>
208           <para> See <xref LinkEnd="instance-decls">.  Only relevant
209           if you also use <option>-fglasgow-exts</option>.</para>
210         </listitem>
211       </varlistentry>
212
213       <varlistentry>
214         <term><option>-finline-phase</option></term>
215         <indexterm><primary><option>-finline-phase</option></primary></indexterm>
216         <listitem>
217           <para>See <xref LinkEnd="rewrite-rules">.  Only relevant if
218           you also use <option>-fglasgow-exts</option>.</para>
219         </listitem>
220       </varlistentry>
221
222       <varlistentry>
223         <term><option>-fgenerics</option></term>
224         <indexterm><primary><option>-fgenerics</option></primary></indexterm>
225         <listitem>
226           <para>See <xref LinkEnd="generic-classes">.  Independent of
227           <option>-fglasgow-exts</option>.</para>
228         </listitem>
229       </varlistentry>
230
231         <varlistentry>
232           <term><option>-fno-implicit-prelude</option></term>
233           <listitem>
234             <para><indexterm><primary>-fno-implicit-prelude
235             option</primary></indexterm> GHC normally imports
236             <filename>Prelude.hi</filename> files for you.  If you'd
237             rather it didn't, then give it a
238             <option>-fno-implicit-prelude</option> option.  The idea
239             is that you can then import a Prelude of your own.  (But
240             don't call it <literal>Prelude</literal>; the Haskell
241             module namespace is flat, and you must not conflict with
242             any Prelude module.)</para>
243
244             <para>Even though you have not imported the Prelude, all
245             the built-in syntax still refers to the built-in Haskell
246             Prelude types and values, as specified by the Haskell
247             Report.  For example, the type <literal>[Int]</literal>
248             still means <literal>Prelude.[] Int</literal>; tuples
249             continue to refer to the standard Prelude tuples; the
250             translation for list comprehensions continues to use
251             <literal>Prelude.map</literal> etc.</para>
252
253             <para> With one group of exceptions!  You may want to
254             define your own numeric class hierarchy.  It completely
255             defeats that purpose if the literal "1" means
256             "<literal>Prelude.fromInteger 1</literal>", which is what
257             the Haskell Report specifies.  So the
258             <option>-fno-implicit-prelude</option> flag causes the
259             following pieces of built-in syntax to refer to <emphasis>whatever
260             is in scope</emphasis>, not the Prelude versions:</para>
261
262             <itemizedlist>
263               <listitem>
264                 <para>Integer and fractional literals mean
265                 "<literal>fromInteger 1</literal>" and
266                 "<literal>fromRational 3.2</literal>", not the
267                 Prelude-qualified versions; both in expressions and in
268                 patterns.</para>
269               </listitem>
270
271               <listitem>
272                 <para>Negation (e.g. "<literal>- (f x)</literal>")
273                 means "<literal>negate (f x)</literal>" (not
274                 <literal>Prelude.negate</literal>).</para>
275               </listitem>
276
277               <listitem>
278                 <para>In an n+k pattern, the standard Prelude
279                 <literal>Ord</literal> class is still used for comparison,
280                 but the necessary subtraction uses whatever
281                 "<literal>(-)</literal>" is in scope (not
282                 "<literal>Prelude.(-)</literal>").</para>
283               </listitem>
284             </itemizedlist>
285
286              <para>Note: Negative literals, such as <literal>-3</literal>, are
287              specified by (a careful reading of) the Haskell Report as 
288              meaning <literal>Prelude.negate (Prelude.fromInteger 3)</literal>.
289              However, GHC deviates from this slightly, and treats them as meaning
290              <literal>fromInteger (-3)</literal>.  One particular effect of this
291              slightly-non-standard reading is that there is no difficulty with
292              the literal <literal>-2147483648</literal> at type <literal>Int</literal>;
293              it means <literal>fromInteger (-2147483648)</literal>.  The strict interpretation
294              would be <literal>negate (fromInteger 2147483648)</literal>,
295              and the call to <literal>fromInteger</literal> would overflow
296              (at type <literal>Int</literal>, remember).
297              </para>
298
299           </listitem>
300         </varlistentry>
301
302     </variablelist>
303   </sect1>
304
305 <!-- UNBOXED TYPES AND PRIMITIVE OPERATIONS -->
306 &primitives;
307
308 <sect1 id="glasgow-ST-monad">
309 <title>Primitive state-transformer monad</title>
310
311 <para>
312 <indexterm><primary>state transformers (Glasgow extensions)</primary></indexterm>
313 <indexterm><primary>ST monad (Glasgow extension)</primary></indexterm>
314 </para>
315
316 <para>
317 This monad underlies our implementation of arrays, mutable and
318 immutable, and our implementation of I/O, including &ldquo;C calls&rdquo;.
319 </para>
320
321 <para>
322 The <literal>ST</literal> library, which provides access to the
323 <function>ST</function> monad, is described in <xref
324 linkend="sec-ST">.
325 </para>
326
327 </sect1>
328
329 <sect1 id="glasgow-prim-arrays">
330 <title>Primitive arrays, mutable and otherwise
331 </title>
332
333 <para>
334 <indexterm><primary>primitive arrays (Glasgow extension)</primary></indexterm>
335 <indexterm><primary>arrays, primitive (Glasgow extension)</primary></indexterm>
336 </para>
337
338 <para>
339 GHC knows about quite a few flavours of Large Swathes of Bytes.
340 </para>
341
342 <para>
343 First, GHC distinguishes between primitive arrays of (boxed) Haskell
344 objects (type <literal>Array&num; obj</literal>) and primitive arrays of bytes (type
345 <literal>ByteArray&num;</literal>).
346 </para>
347
348 <para>
349 Second, it distinguishes between&hellip;
350 <variablelist>
351
352 <varlistentry>
353 <term>Immutable:</term>
354 <listitem>
355 <para>
356 Arrays that do not change (as with &ldquo;standard&rdquo; Haskell arrays); you
357 can only read from them.  Obviously, they do not need the care and
358 attention of the state-transformer monad.
359 </para>
360 </listitem>
361 </varlistentry>
362 <varlistentry>
363 <term>Mutable:</term>
364 <listitem>
365 <para>
366 Arrays that may be changed or &ldquo;mutated.&rdquo;  All the operations on them
367 live within the state-transformer monad and the updates happen
368 <emphasis>in-place</emphasis>.
369 </para>
370 </listitem>
371 </varlistentry>
372 <varlistentry>
373 <term>&ldquo;Static&rdquo; (in C land):</term>
374 <listitem>
375 <para>
376 A C routine may pass an <literal>Addr&num;</literal> pointer back into Haskell land.  There
377 are then primitive operations with which you may merrily grab values
378 over in C land, by indexing off the &ldquo;static&rdquo; pointer.
379 </para>
380 </listitem>
381 </varlistentry>
382 <varlistentry>
383 <term>&ldquo;Stable&rdquo; pointers:</term>
384 <listitem>
385 <para>
386 If, for some reason, you wish to hand a Haskell pointer (i.e.,
387 <emphasis>not</emphasis> an unboxed value) to a C routine, you first make the
388 pointer &ldquo;stable,&rdquo; so that the garbage collector won't forget that it
389 exists.  That is, GHC provides a safe way to pass Haskell pointers to
390 C.
391 </para>
392
393 <para>
394 Please see <xref LinkEnd="sec-stable-pointers"> for more details.
395 </para>
396 </listitem>
397 </varlistentry>
398 <varlistentry>
399 <term>&ldquo;Foreign objects&rdquo;:</term>
400 <listitem>
401 <para>
402 A &ldquo;foreign object&rdquo; is a safe way to pass an external object (a
403 C-allocated pointer, say) to Haskell and have Haskell do the Right
404 Thing when it no longer references the object.  So, for example, C
405 could pass a large bitmap over to Haskell and say &ldquo;please free this
406 memory when you're done with it.&rdquo;
407 </para>
408
409 <para>
410 Please see <xref LinkEnd="sec-ForeignObj"> for more details.
411 </para>
412 </listitem>
413 </varlistentry>
414 </variablelist>
415 </para>
416
417 <para>
418 The libraries documentatation gives more details on all these
419 &ldquo;primitive array&rdquo; types and the operations on them.
420 </para>
421
422 </sect1>
423
424
425 <sect1 id="nullary-types">
426 <title>Data types with no constructors</title>
427
428 <para>With the <option>-fglasgow-exts</option> flag, GHC lets you declare
429 a data type with no constructors.  For example:</para>
430 <programlisting>
431   data S      -- S :: *
432   data T a    -- T :: * -> *
433 </programlisting>
434 <para>Syntactically, the declaration lacks the "= constrs" part.  The 
435 type can be parameterised, but only over ordinary types, of kind *; since
436 Haskell does not have kind signatures, you cannot parameterise over higher-kinded
437 types.</para>
438
439 <para>Such data types have only one value, namely bottom.
440 Nevertheless, they can be useful when defining "phantom types".</para>
441 </sect1>
442
443 <sect1 id="pattern-guards">
444 <title>Pattern guards</title>
445
446 <para>
447 <indexterm><primary>Pattern guards (Glasgow extension)</primary></indexterm>
448 The discussion that follows is an abbreviated version of Simon Peyton Jones's original <ULink URL="http://research.microsoft.com/~simonpj/Haskell/guards.html">proposal</ULink>. (Note that the proposal was written before pattern guards were implemented, so refers to them as unimplemented.)
449 </para>
450
451 <para>
452 Suppose we have an abstract data type of finite maps, with a
453 lookup operation:
454
455 <programlisting>
456 lookup :: FiniteMap -> Int -> Maybe Int
457 </programlisting>
458
459 The lookup returns <function>Nothing</function> if the supplied key is not in the domain of the mapping, and <function>(Just v)</function> otherwise,
460 where <VarName>v</VarName> is the value that the key maps to.  Now consider the following definition:
461 </para>
462
463 <programlisting>
464 clunky env var1 var2 | ok1 && ok2 = val1 + val2
465 | otherwise  = var1 + var2
466 where
467   m1 = lookup env var1
468   m2 = lookup env var2
469   ok1 = maybeToBool m1
470   ok2 = maybeToBool m2
471   val1 = expectJust m1
472   val2 = expectJust m2
473 </programlisting>
474
475 <para>
476 The auxiliary functions are 
477 </para>
478
479 <programlisting>
480 maybeToBool :: Maybe a -&gt; Bool
481 maybeToBool (Just x) = True
482 maybeToBool Nothing  = False
483
484 expectJust :: Maybe a -&gt; a
485 expectJust (Just x) = x
486 expectJust Nothing  = error "Unexpected Nothing"
487 </programlisting>
488
489 <para>
490 What is <function>clunky</function> doing? The guard <literal>ok1 &&
491 ok2</literal> checks that both lookups succeed, using
492 <function>maybeToBool</function> to convert the <function>Maybe</function>
493 types to booleans. The (lazily evaluated) <function>expectJust</function>
494 calls extract the values from the results of the lookups, and binds the
495 returned values to <VarName>val1</VarName> and <VarName>val2</VarName>
496 respectively.  If either lookup fails, then clunky takes the
497 <literal>otherwise</literal> case and returns the sum of its arguments.
498 </para>
499
500 <para>
501 This is certainly legal Haskell, but it is a tremendously verbose and
502 un-obvious way to achieve the desired effect.  Arguably, a more direct way
503 to write clunky would be to use case expressions:
504 </para>
505
506 <programlisting>
507 clunky env var1 var1 = case lookup env var1 of
508   Nothing -&gt; fail
509   Just val1 -&gt; case lookup env var2 of
510     Nothing -&gt; fail
511     Just val2 -&gt; val1 + val2
512 where
513   fail = val1 + val2
514 </programlisting>
515
516 <para>
517 This is a bit shorter, but hardly better.  Of course, we can rewrite any set
518 of pattern-matching, guarded equations as case expressions; that is
519 precisely what the compiler does when compiling equations! The reason that
520 Haskell provides guarded equations is because they allow us to write down
521 the cases we want to consider, one at a time, independently of each other. 
522 This structure is hidden in the case version.  Two of the right-hand sides
523 are really the same (<function>fail</function>), and the whole expression
524 tends to become more and more indented. 
525 </para>
526
527 <para>
528 Here is how I would write clunky:
529 </para>
530
531 <programlisting>
532 clunky env var1 var1
533   | Just val1 &lt;- lookup env var1
534   , Just val2 &lt;- lookup env var2
535   = val1 + val2
536 ...other equations for clunky...
537 </programlisting>
538
539 <para>
540 The semantics should be clear enough.  The qualifers are matched in order. 
541 For a <literal>&lt;-</literal> qualifier, which I call a pattern guard, the
542 right hand side is evaluated and matched against the pattern on the left. 
543 If the match fails then the whole guard fails and the next equation is
544 tried.  If it succeeds, then the appropriate binding takes place, and the
545 next qualifier is matched, in the augmented environment.  Unlike list
546 comprehensions, however, the type of the expression to the right of the
547 <literal>&lt;-</literal> is the same as the type of the pattern to its
548 left.  The bindings introduced by pattern guards scope over all the
549 remaining guard qualifiers, and over the right hand side of the equation.
550 </para>
551
552 <para>
553 Just as with list comprehensions, boolean expressions can be freely mixed
554 with among the pattern guards.  For example:
555 </para>
556
557 <programlisting>
558 f x | [y] <- x
559     , y > 3
560     , Just z <- h y
561     = ...
562 </programlisting>
563
564 <para>
565 Haskell's current guards therefore emerge as a special case, in which the
566 qualifier list has just one element, a boolean expression.
567 </para>
568 </sect1>
569
570   <sect1 id="parallel-list-comprehensions">
571     <title>Parallel List Comprehensions</title>
572     <indexterm><primary>list comprehensions</primary><secondary>parallel</secondary>
573     </indexterm>
574     <indexterm><primary>parallel list comprehensions</primary>
575     </indexterm>
576
577     <para>Parallel list comprehensions are a natural extension to list
578     comprehensions.  List comprehensions can be thought of as a nice
579     syntax for writing maps and filters.  Parallel comprehensions
580     extend this to include the zipWith family.</para>
581
582     <para>A parallel list comprehension has multiple independent
583     branches of qualifier lists, each separated by a `|' symbol.  For
584     example, the following zips together two lists:</para>
585
586 <programlisting>
587    [ (x, y) | x <- xs | y <- ys ] 
588 </programlisting>
589
590     <para>The behavior of parallel list comprehensions follows that of
591     zip, in that the resulting list will have the same length as the
592     shortest branch.</para>
593
594     <para>We can define parallel list comprehensions by translation to
595     regular comprehensions.  Here's the basic idea:</para>
596
597     <para>Given a parallel comprehension of the form: </para>
598
599 <programlisting>
600    [ e | p1 <- e11, p2 <- e12, ... 
601        | q1 <- e21, q2 <- e22, ... 
602        ... 
603    ] 
604 </programlisting>
605
606     <para>This will be translated to: </para>
607
608 <programlisting>
609    [ e | ((p1,p2), (q1,q2), ...) <- zipN [(p1,p2) | p1 <- e11, p2 <- e12, ...] 
610                                          [(q1,q2) | q1 <- e21, q2 <- e22, ...] 
611                                          ... 
612    ] 
613 </programlisting>
614
615     <para>where `zipN' is the appropriate zip for the given number of
616     branches.</para>
617
618   </sect1>
619
620   <sect1 id="sec-ffi">
621     <title>The foreign interface</title>
622
623     <para>The foreign interface consists of the following components:</para>
624
625     <itemizedlist>
626       <listitem>
627         <para>The Foreign Function Interface language specification
628         (included in this manual, in <xref linkend="ffi">).
629         You must use the <option>-fglasgow-exts</option> command-line option
630         to make GHC understand the <literal>foreign</literal> declarations
631         defined by the FFI.</para>
632       </listitem>
633
634       <listitem>
635         <para>The <literal>Foreign</literal> module (see <xref
636         linkend="sec-Foreign">) collects together several interfaces
637         which are useful in specifying foreign language
638         interfaces, including the following:</para>
639
640         <itemizedlist>
641           <listitem>
642             <para>The <literal>ForeignObj</literal> module (see <xref
643             linkend="sec-ForeignObj">), for managing pointers from
644             Haskell into the outside world.</para>
645           </listitem>
646       
647           <listitem>
648             <para>The <literal>StablePtr</literal> module (see <xref
649             linkend="sec-stable-pointers">), for managing pointers
650             into Haskell from the outside world.</para>
651           </listitem>
652       
653           <listitem>
654             <para>The <literal>CTypes</literal> module (see <xref
655             linkend="sec-CTypes">) gives Haskell equivalents for the
656             standard C datatypes, for use in making Haskell bindings
657             to existing C libraries.</para>
658           </listitem>
659       
660           <listitem>
661             <para>The <literal>CTypesISO</literal> module (see <xref
662             linkend="sec-CTypesISO">) gives Haskell equivalents for C
663             types defined by the ISO C standard.</para>
664           </listitem>
665       
666           <listitem>
667             <para>The <literal>Storable</literal> library, for
668             primitive marshalling of data types between Haskell and
669             the foreign language.</para>
670           </listitem>
671         </itemizedlist>
672
673       </listitem>
674     </itemizedlist>
675
676 <para>The following sections also give some hints and tips on the use
677 of the foreign function interface in GHC.</para>
678
679 <sect2 id="glasgow-foreign-headers">
680 <title>Using function headers
681 </title>
682
683 <para>
684 <indexterm><primary>C calls, function headers</primary></indexterm>
685 </para>
686
687 <para>
688 When generating C (using the <option>-fvia-C</option> directive), one can assist the
689 C compiler in detecting type errors by using the <option>-&num;include</option> directive
690 (<xref linkend="options-C-compiler">) to provide <filename>.h</filename> files containing function headers.
691 </para>
692
693 <para>
694 For example,
695 </para>
696
697 <para>
698
699 <programlisting>
700 #include "HsFFI.h"
701
702 void         initialiseEFS (HsInt size);
703 HsInt        terminateEFS (void);
704 HsForeignObj emptyEFS(void);
705 HsForeignObj updateEFS (HsForeignObj a, HsInt i, HsInt x);
706 HsInt        lookupEFS (HsForeignObj a, HsInt i);
707 </programlisting>
708 </para>
709
710       <para>The types <literal>HsInt</literal>,
711       <literal>HsForeignObj</literal> etc. are described in <xref
712       linkend="sec-mapping-table">.</para>
713
714       <para>Note that this approach is only
715       <emphasis>essential</emphasis> for returning
716       <literal>float</literal>s (or if <literal>sizeof(int) !=
717       sizeof(int *)</literal> on your architecture) but is a Good
718       Thing for anyone who cares about writing solid code.  You're
719       crazy not to do it.</para>
720
721 </sect2>
722
723 </sect1>
724
725 <sect1 id="multi-param-type-classes">
726 <title>Multi-parameter type classes
727 </title>
728
729 <para>
730 This section documents GHC's implementation of multi-parameter type
731 classes.  There's lots of background in the paper <ULink
732 URL="http://research.microsoft.com/~simonpj/multi.ps.gz" >Type
733 classes: exploring the design space</ULink > (Simon Peyton Jones, Mark
734 Jones, Erik Meijer).
735 </para>
736
737 <para>
738 I'd like to thank people who reported shorcomings in the GHC 3.02
739 implementation.  Our default decisions were all conservative ones, and
740 the experience of these heroic pioneers has given useful concrete
741 examples to support several generalisations.  (These appear below as
742 design choices not implemented in 3.02.)
743 </para>
744
745 <para>
746 I've discussed these notes with Mark Jones, and I believe that Hugs
747 will migrate towards the same design choices as I outline here.
748 Thanks to him, and to many others who have offered very useful
749 feedback.
750 </para>
751
752 <sect2>
753 <title>Types</title>
754
755 <para>
756 There are the following restrictions on the form of a qualified
757 type:
758 </para>
759
760 <para>
761
762 <programlisting>
763   forall tv1..tvn (c1, ...,cn) => type
764 </programlisting>
765
766 </para>
767
768 <para>
769 (Here, I write the "foralls" explicitly, although the Haskell source
770 language omits them; in Haskell 1.4, all the free type variables of an
771 explicit source-language type signature are universally quantified,
772 except for the class type variables in a class declaration.  However,
773 in GHC, you can give the foralls if you want.  See <xref LinkEnd="universal-quantification">).
774 </para>
775
776 <para>
777
778 <OrderedList>
779 <listitem>
780
781 <para>
782  <emphasis>Each universally quantified type variable
783 <literal>tvi</literal> must be mentioned (i.e. appear free) in <literal>type</literal></emphasis>.
784
785 The reason for this is that a value with a type that does not obey
786 this restriction could not be used without introducing
787 ambiguity. Here, for example, is an illegal type:
788
789
790 <programlisting>
791   forall a. Eq a => Int
792 </programlisting>
793
794
795 When a value with this type was used, the constraint <literal>Eq tv</literal>
796 would be introduced where <literal>tv</literal> is a fresh type variable, and
797 (in the dictionary-translation implementation) the value would be
798 applied to a dictionary for <literal>Eq tv</literal>.  The difficulty is that we
799 can never know which instance of <literal>Eq</literal> to use because we never
800 get any more information about <literal>tv</literal>.
801
802 </para>
803 </listitem>
804 <listitem>
805
806 <para>
807  <emphasis>Every constraint <literal>ci</literal> must mention at least one of the
808 universally quantified type variables <literal>tvi</literal></emphasis>.
809
810 For example, this type is OK because <literal>C a b</literal> mentions the
811 universally quantified type variable <literal>b</literal>:
812
813
814 <programlisting>
815   forall a. C a b => burble
816 </programlisting>
817
818
819 The next type is illegal because the constraint <literal>Eq b</literal> does not
820 mention <literal>a</literal>:
821
822
823 <programlisting>
824   forall a. Eq b => burble
825 </programlisting>
826
827
828 The reason for this restriction is milder than the other one.  The
829 excluded types are never useful or necessary (because the offending
830 context doesn't need to be witnessed at this point; it can be floated
831 out).  Furthermore, floating them out increases sharing. Lastly,
832 excluding them is a conservative choice; it leaves a patch of
833 territory free in case we need it later.
834
835 </para>
836 </listitem>
837
838 </OrderedList>
839
840 </para>
841
842 <para>
843 These restrictions apply to all types, whether declared in a type signature
844 or inferred.
845 </para>
846
847 <para>
848 Unlike Haskell 1.4, constraints in types do <emphasis>not</emphasis> have to be of
849 the form <emphasis>(class type-variables)</emphasis>.  Thus, these type signatures
850 are perfectly OK
851 </para>
852
853 <para>
854
855 <programlisting>
856   f :: Eq (m a) => [m a] -> [m a]
857   g :: Eq [a] => ...
858 </programlisting>
859
860 </para>
861
862 <para>
863 This choice recovers principal types, a property that Haskell 1.4 does not have.
864 </para>
865
866 </sect2>
867
868 <sect2>
869 <title>Class declarations</title>
870
871 <para>
872
873 <OrderedList>
874 <listitem>
875
876 <para>
877  <emphasis>Multi-parameter type classes are permitted</emphasis>. For example:
878
879
880 <programlisting>
881   class Collection c a where
882     union :: c a -> c a -> c a
883     ...etc.
884 </programlisting>
885
886
887
888 </para>
889 </listitem>
890 <listitem>
891
892 <para>
893  <emphasis>The class hierarchy must be acyclic</emphasis>.  However, the definition
894 of "acyclic" involves only the superclass relationships.  For example,
895 this is OK:
896
897
898 <programlisting>
899   class C a where {
900     op :: D b => a -> b -> b
901   }
902
903   class C a => D a where { ... }
904 </programlisting>
905
906
907 Here, <literal>C</literal> is a superclass of <literal>D</literal>, but it's OK for a
908 class operation <literal>op</literal> of <literal>C</literal> to mention <literal>D</literal>.  (It
909 would not be OK for <literal>D</literal> to be a superclass of <literal>C</literal>.)
910
911 </para>
912 </listitem>
913 <listitem>
914
915 <para>
916  <emphasis>There are no restrictions on the context in a class declaration
917 (which introduces superclasses), except that the class hierarchy must
918 be acyclic</emphasis>.  So these class declarations are OK:
919
920
921 <programlisting>
922   class Functor (m k) => FiniteMap m k where
923     ...
924
925   class (Monad m, Monad (t m)) => Transform t m where
926     lift :: m a -> (t m) a
927 </programlisting>
928
929
930 </para>
931 </listitem>
932 <listitem>
933
934 <para>
935  <emphasis>In the signature of a class operation, every constraint
936 must mention at least one type variable that is not a class type
937 variable</emphasis>.
938
939 Thus:
940
941
942 <programlisting>
943   class Collection c a where
944     mapC :: Collection c b => (a->b) -> c a -> c b
945 </programlisting>
946
947
948 is OK because the constraint <literal>(Collection a b)</literal> mentions
949 <literal>b</literal>, even though it also mentions the class variable
950 <literal>a</literal>.  On the other hand:
951
952
953 <programlisting>
954   class C a where
955     op :: Eq a => (a,b) -> (a,b)
956 </programlisting>
957
958
959 is not OK because the constraint <literal>(Eq a)</literal> mentions on the class
960 type variable <literal>a</literal>, but not <literal>b</literal>.  However, any such
961 example is easily fixed by moving the offending context up to the
962 superclass context:
963
964
965 <programlisting>
966   class Eq a => C a where
967     op ::(a,b) -> (a,b)
968 </programlisting>
969
970
971 A yet more relaxed rule would allow the context of a class-op signature
972 to mention only class type variables.  However, that conflicts with
973 Rule 1(b) for types above.
974
975 </para>
976 </listitem>
977 <listitem>
978
979 <para>
980  <emphasis>The type of each class operation must mention <emphasis>all</emphasis> of
981 the class type variables</emphasis>.  For example:
982
983
984 <programlisting>
985   class Coll s a where
986     empty  :: s
987     insert :: s -> a -> s
988 </programlisting>
989
990
991 is not OK, because the type of <literal>empty</literal> doesn't mention
992 <literal>a</literal>.  This rule is a consequence of Rule 1(a), above, for
993 types, and has the same motivation.
994
995 Sometimes, offending class declarations exhibit misunderstandings.  For
996 example, <literal>Coll</literal> might be rewritten
997
998
999 <programlisting>
1000   class Coll s a where
1001     empty  :: s a
1002     insert :: s a -> a -> s a
1003 </programlisting>
1004
1005
1006 which makes the connection between the type of a collection of
1007 <literal>a</literal>'s (namely <literal>(s a)</literal>) and the element type <literal>a</literal>.
1008 Occasionally this really doesn't work, in which case you can split the
1009 class like this:
1010
1011
1012 <programlisting>
1013   class CollE s where
1014     empty  :: s
1015
1016   class CollE s => Coll s a where
1017     insert :: s -> a -> s
1018 </programlisting>
1019
1020
1021 </para>
1022 </listitem>
1023
1024 </OrderedList>
1025
1026 </para>
1027
1028 </sect2>
1029
1030 <sect2 id="instance-decls">
1031 <title>Instance declarations</title>
1032
1033 <para>
1034
1035 <OrderedList>
1036 <listitem>
1037
1038 <para>
1039  <emphasis>Instance declarations may not overlap</emphasis>.  The two instance
1040 declarations
1041
1042
1043 <programlisting>
1044   instance context1 => C type1 where ...
1045   instance context2 => C type2 where ...
1046 </programlisting>
1047
1048
1049 "overlap" if <literal>type1</literal> and <literal>type2</literal> unify
1050
1051 However, if you give the command line option
1052 <option>-fallow-overlapping-instances</option><indexterm><primary>-fallow-overlapping-instances
1053 option</primary></indexterm> then two overlapping instance declarations are permitted
1054 iff
1055
1056
1057 <itemizedlist>
1058 <listitem>
1059
1060 <para>
1061  EITHER <literal>type1</literal> and <literal>type2</literal> do not unify
1062 </para>
1063 </listitem>
1064 <listitem>
1065
1066 <para>
1067  OR <literal>type2</literal> is a substitution instance of <literal>type1</literal>
1068 (but not identical to <literal>type1</literal>)
1069 </para>
1070 </listitem>
1071 <listitem>
1072
1073 <para>
1074  OR vice versa
1075 </para>
1076 </listitem>
1077
1078 </itemizedlist>
1079
1080
1081 Notice that these rules
1082
1083
1084 <itemizedlist>
1085 <listitem>
1086
1087 <para>
1088  make it clear which instance decl to use
1089 (pick the most specific one that matches)
1090
1091 </para>
1092 </listitem>
1093 <listitem>
1094
1095 <para>
1096  do not mention the contexts <literal>context1</literal>, <literal>context2</literal>
1097 Reason: you can pick which instance decl
1098 "matches" based on the type.
1099 </para>
1100 </listitem>
1101
1102 </itemizedlist>
1103
1104
1105 Regrettably, GHC doesn't guarantee to detect overlapping instance
1106 declarations if they appear in different modules.  GHC can "see" the
1107 instance declarations in the transitive closure of all the modules
1108 imported by the one being compiled, so it can "see" all instance decls
1109 when it is compiling <literal>Main</literal>.  However, it currently chooses not
1110 to look at ones that can't possibly be of use in the module currently
1111 being compiled, in the interests of efficiency.  (Perhaps we should
1112 change that decision, at least for <literal>Main</literal>.)
1113
1114 </para>
1115 </listitem>
1116 <listitem>
1117
1118 <para>
1119  <emphasis>There are no restrictions on the type in an instance
1120 <emphasis>head</emphasis>, except that at least one must not be a type variable</emphasis>.
1121 The instance "head" is the bit after the "=>" in an instance decl. For
1122 example, these are OK:
1123
1124
1125 <programlisting>
1126   instance C Int a where ...
1127
1128   instance D (Int, Int) where ...
1129
1130   instance E [[a]] where ...
1131 </programlisting>
1132
1133
1134 Note that instance heads <emphasis>may</emphasis> contain repeated type variables.
1135 For example, this is OK:
1136
1137
1138 <programlisting>
1139   instance Stateful (ST s) (MutVar s) where ...
1140 </programlisting>
1141
1142
1143 The "at least one not a type variable" restriction is to ensure that
1144 context reduction terminates: each reduction step removes one type
1145 constructor.  For example, the following would make the type checker
1146 loop if it wasn't excluded:
1147
1148
1149 <programlisting>
1150   instance C a => C a where ...
1151 </programlisting>
1152
1153
1154 There are two situations in which the rule is a bit of a pain. First,
1155 if one allows overlapping instance declarations then it's quite
1156 convenient to have a "default instance" declaration that applies if
1157 something more specific does not:
1158
1159
1160 <programlisting>
1161   instance C a where
1162     op = ... -- Default
1163 </programlisting>
1164
1165
1166 Second, sometimes you might want to use the following to get the
1167 effect of a "class synonym":
1168
1169
1170 <programlisting>
1171   class (C1 a, C2 a, C3 a) => C a where { }
1172
1173   instance (C1 a, C2 a, C3 a) => C a where { }
1174 </programlisting>
1175
1176
1177 This allows you to write shorter signatures:
1178
1179
1180 <programlisting>
1181   f :: C a => ...
1182 </programlisting>
1183
1184
1185 instead of
1186
1187
1188 <programlisting>
1189   f :: (C1 a, C2 a, C3 a) => ...
1190 </programlisting>
1191
1192
1193 I'm on the lookout for a simple rule that preserves decidability while
1194 allowing these idioms.  The experimental flag
1195 <option>-fallow-undecidable-instances</option><indexterm><primary>-fallow-undecidable-instances
1196 option</primary></indexterm> lifts this restriction, allowing all the types in an
1197 instance head to be type variables.
1198
1199 </para>
1200 </listitem>
1201 <listitem>
1202
1203 <para>
1204  <emphasis>Unlike Haskell 1.4, instance heads may use type
1205 synonyms</emphasis>.  As always, using a type synonym is just shorthand for
1206 writing the RHS of the type synonym definition.  For example:
1207
1208
1209 <programlisting>
1210   type Point = (Int,Int)
1211   instance C Point   where ...
1212   instance C [Point] where ...
1213 </programlisting>
1214
1215
1216 is legal.  However, if you added
1217
1218
1219 <programlisting>
1220   instance C (Int,Int) where ...
1221 </programlisting>
1222
1223
1224 as well, then the compiler will complain about the overlapping
1225 (actually, identical) instance declarations.  As always, type synonyms
1226 must be fully applied.  You cannot, for example, write:
1227
1228
1229 <programlisting>
1230   type P a = [[a]]
1231   instance Monad P where ...
1232 </programlisting>
1233
1234
1235 This design decision is independent of all the others, and easily
1236 reversed, but it makes sense to me.
1237
1238 </para>
1239 </listitem>
1240 <listitem>
1241
1242 <para>
1243 <emphasis>The types in an instance-declaration <emphasis>context</emphasis> must all
1244 be type variables</emphasis>. Thus
1245
1246
1247 <programlisting>
1248 instance C a b => Eq (a,b) where ...
1249 </programlisting>
1250
1251
1252 is OK, but
1253
1254
1255 <programlisting>
1256 instance C Int b => Foo b where ...
1257 </programlisting>
1258
1259
1260 is not OK.  Again, the intent here is to make sure that context
1261 reduction terminates.
1262
1263 Voluminous correspondence on the Haskell mailing list has convinced me
1264 that it's worth experimenting with a more liberal rule.  If you use
1265 the flag <option>-fallow-undecidable-instances</option> can use arbitrary
1266 types in an instance context.  Termination is ensured by having a
1267 fixed-depth recursion stack.  If you exceed the stack depth you get a
1268 sort of backtrace, and the opportunity to increase the stack depth
1269 with <option>-fcontext-stack</option><emphasis>N</emphasis>.
1270
1271 </para>
1272 </listitem>
1273
1274 </OrderedList>
1275
1276 </para>
1277
1278 </sect2>
1279
1280 </sect1>
1281
1282 <sect1 id="implicit-parameters">
1283 <title>Implicit parameters
1284 </title>
1285
1286 <para> Implicit paramters are implemented as described in 
1287 "Implicit parameters: dynamic scoping with static types", 
1288 J Lewis, MB Shields, E Meijer, J Launchbury,
1289 27th ACM Symposium on Principles of Programming Languages (POPL'00),
1290 Boston, Jan 2000.
1291 </para>
1292
1293 <para>
1294 There should be more documentation, but there isn't (yet).  Yell if you need it.
1295 </para>
1296 <itemizedlist>
1297 <listitem>
1298 <para> You can't have an implicit parameter in the context of a class or instance
1299 declaration.  For example, both these declarations are illegal:
1300 <programlisting>
1301   class (?x::Int) => C a where ...
1302   instance (?x::a) => Foo [a] where ...
1303 </programlisting>
1304 Reason: exactly which implicit parameter you pick up depends on exactly where
1305 you invoke a function. But the ``invocation'' of instance declarations is done
1306 behind the scenes by the compiler, so it's hard to figure out exactly where it is done.
1307 Easiest thing is to outlaw the offending types.</para>
1308 </listitem>
1309
1310 </itemizedlist>
1311
1312 </sect1>
1313
1314
1315 <sect1 id="functional-dependencies">
1316 <title>Functional dependencies
1317 </title>
1318
1319 <para> Functional dependencies are implemented as described by Mark Jones
1320 in "Type Classes with Functional Dependencies", Mark P. Jones, 
1321 In Proceedings of the 9th European Symposium on Programming, 
1322 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782.
1323 </para>
1324
1325 <para>
1326 There should be more documentation, but there isn't (yet).  Yell if you need it.
1327 </para>
1328 </sect1>
1329
1330
1331 <sect1 id="universal-quantification">
1332 <title>Explicit universal quantification
1333 </title>
1334
1335 <para>
1336 GHC's type system supports explicit universal quantification in
1337 constructor fields and function arguments.  This is useful for things
1338 like defining <literal>runST</literal> from the state-thread world. 
1339 GHC's syntax for this now agrees with Hugs's, namely:
1340 </para>
1341
1342 <para>
1343
1344 <programlisting>
1345         forall a b. (Ord a, Eq  b) => a -> b -> a
1346 </programlisting>
1347
1348 </para>
1349
1350 <para>
1351 The context is, of course, optional.  You can't use <literal>forall</literal> as
1352 a type variable any more!
1353 </para>
1354
1355 <para>
1356 Haskell type signatures are implicitly quantified.  The <literal>forall</literal>
1357 allows us to say exactly what this means.  For example:
1358 </para>
1359
1360 <para>
1361
1362 <programlisting>
1363         g :: b -> b
1364 </programlisting>
1365
1366 </para>
1367
1368 <para>
1369 means this:
1370 </para>
1371
1372 <para>
1373
1374 <programlisting>
1375         g :: forall b. (b -> b)
1376 </programlisting>
1377
1378 </para>
1379
1380 <para>
1381 The two are treated identically.
1382 </para>
1383
1384 <sect2 id="univ">
1385 <title>Universally-quantified data type fields
1386 </title>
1387
1388 <para>
1389 In a <literal>data</literal> or <literal>newtype</literal> declaration one can quantify
1390 the types of the constructor arguments.  Here are several examples:
1391 </para>
1392
1393 <para>
1394
1395 <programlisting>
1396 data T a = T1 (forall b. b -> b -> b) a
1397
1398 data MonadT m = MkMonad { return :: forall a. a -> m a,
1399                           bind   :: forall a b. m a -> (a -> m b) -> m b
1400                         }
1401
1402 newtype Swizzle = MkSwizzle (Ord a => [a] -> [a])
1403 </programlisting>
1404
1405 </para>
1406
1407 <para>
1408 The constructors now have so-called <emphasis>rank 2</emphasis> polymorphic
1409 types, in which there is a for-all in the argument types.:
1410 </para>
1411
1412 <para>
1413
1414 <programlisting>
1415 T1 :: forall a. (forall b. b -> b -> b) -> a -> T a
1416 MkMonad :: forall m. (forall a. a -> m a)
1417                   -> (forall a b. m a -> (a -> m b) -> m b)
1418                   -> MonadT m
1419 MkSwizzle :: (Ord a => [a] -> [a]) -> Swizzle
1420 </programlisting>
1421
1422 </para>
1423
1424 <para>
1425 Notice that you don't need to use a <literal>forall</literal> if there's an
1426 explicit context.  For example in the first argument of the
1427 constructor <function>MkSwizzle</function>, an implicit "<literal>forall a.</literal>" is
1428 prefixed to the argument type.  The implicit <literal>forall</literal>
1429 quantifies all type variables that are not already in scope, and are
1430 mentioned in the type quantified over.
1431 </para>
1432
1433 <para>
1434 As for type signatures, implicit quantification happens for non-overloaded
1435 types too.  So if you write this:
1436
1437 <programlisting>
1438   data T a = MkT (Either a b) (b -> b)
1439 </programlisting>
1440
1441 it's just as if you had written this:
1442
1443 <programlisting>
1444   data T a = MkT (forall b. Either a b) (forall b. b -> b)
1445 </programlisting>
1446
1447 That is, since the type variable <literal>b</literal> isn't in scope, it's
1448 implicitly universally quantified.  (Arguably, it would be better
1449 to <emphasis>require</emphasis> explicit quantification on constructor arguments
1450 where that is what is wanted.  Feedback welcomed.)
1451 </para>
1452
1453 </sect2>
1454
1455 <sect2>
1456 <title>Construction </title>
1457
1458 <para>
1459 You construct values of types <literal>T1, MonadT, Swizzle</literal> by applying
1460 the constructor to suitable values, just as usual.  For example,
1461 </para>
1462
1463 <para>
1464
1465 <programlisting>
1466 (T1 (\xy->x) 3) :: T Int
1467
1468 (MkSwizzle sort)    :: Swizzle
1469 (MkSwizzle reverse) :: Swizzle
1470
1471 (let r x = Just x
1472      b m k = case m of
1473                 Just y -> k y
1474                 Nothing -> Nothing
1475   in
1476   MkMonad r b) :: MonadT Maybe
1477 </programlisting>
1478
1479 </para>
1480
1481 <para>
1482 The type of the argument can, as usual, be more general than the type
1483 required, as <literal>(MkSwizzle reverse)</literal> shows.  (<function>reverse</function>
1484 does not need the <literal>Ord</literal> constraint.)
1485 </para>
1486
1487 </sect2>
1488
1489 <sect2>
1490 <title>Pattern matching</title>
1491
1492 <para>
1493 When you use pattern matching, the bound variables may now have
1494 polymorphic types.  For example:
1495 </para>
1496
1497 <para>
1498
1499 <programlisting>
1500         f :: T a -> a -> (a, Char)
1501         f (T1 f k) x = (f k x, f 'c' 'd')
1502
1503         g :: (Ord a, Ord b) => Swizzle -> [a] -> (a -> b) -> [b]
1504         g (MkSwizzle s) xs f = s (map f (s xs))
1505
1506         h :: MonadT m -> [m a] -> m [a]
1507         h m [] = return m []
1508         h m (x:xs) = bind m x           $ \y ->
1509                       bind m (h m xs)   $ \ys ->
1510                       return m (y:ys)
1511 </programlisting>
1512
1513 </para>
1514
1515 <para>
1516 In the function <function>h</function> we use the record selectors <literal>return</literal>
1517 and <literal>bind</literal> to extract the polymorphic bind and return functions
1518 from the <literal>MonadT</literal> data structure, rather than using pattern
1519 matching.
1520 </para>
1521
1522 <para>
1523 You cannot pattern-match against an argument that is polymorphic.
1524 For example:
1525
1526 <programlisting>
1527         newtype TIM s a = TIM (ST s (Maybe a))
1528
1529         runTIM :: (forall s. TIM s a) -> Maybe a
1530         runTIM (TIM m) = runST m
1531 </programlisting>
1532
1533 </para>
1534
1535 <para>
1536 Here the pattern-match fails, because you can't pattern-match against
1537 an argument of type <literal>(forall s. TIM s a)</literal>.  Instead you
1538 must bind the variable and pattern match in the right hand side:
1539
1540 <programlisting>
1541         runTIM :: (forall s. TIM s a) -> Maybe a
1542         runTIM tm = case tm of { TIM m -> runST m }
1543 </programlisting>
1544
1545 The <literal>tm</literal> on the right hand side is (invisibly) instantiated, like
1546 any polymorphic value at its occurrence site, and now you can pattern-match
1547 against it.
1548 </para>
1549
1550 </sect2>
1551
1552 <sect2>
1553 <title>The partial-application restriction</title>
1554
1555 <para>
1556 There is really only one way in which data structures with polymorphic
1557 components might surprise you: you must not partially apply them.
1558 For example, this is illegal:
1559 </para>
1560
1561 <para>
1562
1563 <programlisting>
1564         map MkSwizzle [sort, reverse]
1565 </programlisting>
1566
1567 </para>
1568
1569 <para>
1570 The restriction is this: <emphasis>every subexpression of the program must
1571 have a type that has no for-alls, except that in a function
1572 application (f e1&hellip;en) the partial applications are not subject to
1573 this rule</emphasis>.  The restriction makes type inference feasible.
1574 </para>
1575
1576 <para>
1577 In the illegal example, the sub-expression <literal>MkSwizzle</literal> has the
1578 polymorphic type <literal>(Ord b => [b] -> [b]) -> Swizzle</literal> and is not
1579 a sub-expression of an enclosing application.  On the other hand, this
1580 expression is OK:
1581 </para>
1582
1583 <para>
1584
1585 <programlisting>
1586         map (T1 (\a b -> a)) [1,2,3]
1587 </programlisting>
1588
1589 </para>
1590
1591 <para>
1592 even though it involves a partial application of <function>T1</function>, because
1593 the sub-expression <literal>T1 (\a b -> a)</literal> has type <literal>Int -> T
1594 Int</literal>.
1595 </para>
1596
1597 </sect2>
1598
1599 <sect2 id="sigs">
1600 <title>Type signatures
1601 </title>
1602
1603 <para>
1604 Once you have data constructors with universally-quantified fields, or
1605 constants such as <Constant>runST</Constant> that have rank-2 types, it isn't long
1606 before you discover that you need more!  Consider:
1607 </para>
1608
1609 <para>
1610
1611 <programlisting>
1612   mkTs f x y = [T1 f x, T1 f y]
1613 </programlisting>
1614
1615 </para>
1616
1617 <para>
1618 <function>mkTs</function> is a fuction that constructs some values of type
1619 <literal>T</literal>, using some pieces passed to it.  The trouble is that since
1620 <literal>f</literal> is a function argument, Haskell assumes that it is
1621 monomorphic, so we'll get a type error when applying <function>T1</function> to
1622 it.  This is a rather silly example, but the problem really bites in
1623 practice.  Lots of people trip over the fact that you can't make
1624 "wrappers functions" for <Constant>runST</Constant> for exactly the same reason.
1625 In short, it is impossible to build abstractions around functions with
1626 rank-2 types.
1627 </para>
1628
1629 <para>
1630 The solution is fairly clear.  We provide the ability to give a rank-2
1631 type signature for <emphasis>ordinary</emphasis> functions (not only data
1632 constructors), thus:
1633 </para>
1634
1635 <para>
1636
1637 <programlisting>
1638   mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1639   mkTs f x y = [T1 f x, T1 f y]
1640 </programlisting>
1641
1642 </para>
1643
1644 <para>
1645 This type signature tells the compiler to attribute <literal>f</literal> with
1646 the polymorphic type <literal>(forall b. b -> b -> b)</literal> when type
1647 checking the body of <function>mkTs</function>, so now the application of
1648 <function>T1</function> is fine.
1649 </para>
1650
1651 <para>
1652 There are two restrictions:
1653 </para>
1654
1655 <para>
1656
1657 <itemizedlist>
1658 <listitem>
1659
1660 <para>
1661  You can only define a rank 2 type, specified by the following
1662 grammar:
1663
1664
1665 <programlisting>
1666 rank2type ::= [forall tyvars .] [context =>] funty
1667 funty     ::= ([forall tyvars .] [context =>] ty) -> funty
1668             | ty
1669 ty        ::= ...current Haskell monotype syntax...
1670 </programlisting>
1671
1672
1673 Informally, the universal quantification must all be right at the beginning,
1674 or at the top level of a function argument.
1675
1676 </para>
1677 </listitem>
1678 <listitem>
1679
1680 <para>
1681  There is a restriction on the definition of a function whose
1682 type signature is a rank-2 type: the polymorphic arguments must be
1683 matched on the left hand side of the "<literal>=</literal>" sign.  You can't
1684 define <function>mkTs</function> like this:
1685
1686
1687 <programlisting>
1688 mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1689 mkTs = \ f x y -> [T1 f x, T1 f y]
1690 </programlisting>
1691
1692
1693
1694 The same partial-application rule applies to ordinary functions with
1695 rank-2 types as applied to data constructors.
1696
1697 </para>
1698 </listitem>
1699
1700 </itemizedlist>
1701
1702 </para>
1703
1704 </sect2>
1705
1706
1707 <sect2 id="hoist">
1708 <title>Type synonyms and hoisting
1709 </title>
1710
1711 <para>
1712 GHC also allows you to write a <literal>forall</literal> in a type synonym, thus:
1713 <programlisting>
1714   type Discard a = forall b. a -> b -> a
1715
1716   f :: Discard a
1717   f x y = x
1718 </programlisting>
1719 However, it is often convenient to use these sort of synonyms at the right hand
1720 end of an arrow, thus:
1721 <programlisting>
1722   type Discard a = forall b. a -> b -> a
1723
1724   g :: Int -> Discard Int
1725   g x y z = x+y
1726 </programlisting>
1727 Simply expanding the type synonym would give
1728 <programlisting>
1729   g :: Int -> (forall b. Int -> b -> Int)
1730 </programlisting>
1731 but GHC "hoists" the <literal>forall</literal> to give the isomorphic type
1732 <programlisting>
1733   g :: forall b. Int -> Int -> b -> Int
1734 </programlisting>
1735 In general, the rule is this: <emphasis>to determine the type specified by any explicit
1736 user-written type (e.g. in a type signature), GHC expands type synonyms and then repeatedly
1737 performs the transformation:</emphasis>
1738 <programlisting>
1739   <emphasis>type1</emphasis> -> forall a. <emphasis>type2</emphasis>
1740 ==>
1741   forall a. <emphasis>type1</emphasis> -> <emphasis>type2</emphasis>
1742 </programlisting>
1743 (In fact, GHC tries to retain as much synonym information as possible for use in
1744 error messages, but that is a usability issue.)  This rule applies, of course, whether
1745 or not the <literal>forall</literal> comes from a synonym. For example, here is another
1746 valid way to write <literal>g</literal>'s type signature:
1747 <programlisting>
1748   g :: Int -> Int -> forall b. b -> Int
1749 </programlisting>
1750 </para>
1751 </sect2>
1752
1753 </sect1>
1754
1755 <sect1 id="existential-quantification">
1756 <title>Existentially quantified data constructors
1757 </title>
1758
1759 <para>
1760 The idea of using existential quantification in data type declarations
1761 was suggested by Laufer (I believe, thought doubtless someone will
1762 correct me), and implemented in Hope+. It's been in Lennart
1763 Augustsson's <Command>hbc</Command> Haskell compiler for several years, and
1764 proved very useful.  Here's the idea.  Consider the declaration:
1765 </para>
1766
1767 <para>
1768
1769 <programlisting>
1770   data Foo = forall a. MkFoo a (a -> Bool)
1771            | Nil
1772 </programlisting>
1773
1774 </para>
1775
1776 <para>
1777 The data type <literal>Foo</literal> has two constructors with types:
1778 </para>
1779
1780 <para>
1781
1782 <programlisting>
1783   MkFoo :: forall a. a -> (a -> Bool) -> Foo
1784   Nil   :: Foo
1785 </programlisting>
1786
1787 </para>
1788
1789 <para>
1790 Notice that the type variable <literal>a</literal> in the type of <function>MkFoo</function>
1791 does not appear in the data type itself, which is plain <literal>Foo</literal>.
1792 For example, the following expression is fine:
1793 </para>
1794
1795 <para>
1796
1797 <programlisting>
1798   [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
1799 </programlisting>
1800
1801 </para>
1802
1803 <para>
1804 Here, <literal>(MkFoo 3 even)</literal> packages an integer with a function
1805 <function>even</function> that maps an integer to <literal>Bool</literal>; and <function>MkFoo 'c'
1806 isUpper</function> packages a character with a compatible function.  These
1807 two things are each of type <literal>Foo</literal> and can be put in a list.
1808 </para>
1809
1810 <para>
1811 What can we do with a value of type <literal>Foo</literal>?.  In particular,
1812 what happens when we pattern-match on <function>MkFoo</function>?
1813 </para>
1814
1815 <para>
1816
1817 <programlisting>
1818   f (MkFoo val fn) = ???
1819 </programlisting>
1820
1821 </para>
1822
1823 <para>
1824 Since all we know about <literal>val</literal> and <function>fn</function> is that they
1825 are compatible, the only (useful) thing we can do with them is to
1826 apply <function>fn</function> to <literal>val</literal> to get a boolean.  For example:
1827 </para>
1828
1829 <para>
1830
1831 <programlisting>
1832   f :: Foo -> Bool
1833   f (MkFoo val fn) = fn val
1834 </programlisting>
1835
1836 </para>
1837
1838 <para>
1839 What this allows us to do is to package heterogenous values
1840 together with a bunch of functions that manipulate them, and then treat
1841 that collection of packages in a uniform manner.  You can express
1842 quite a bit of object-oriented-like programming this way.
1843 </para>
1844
1845 <sect2 id="existential">
1846 <title>Why existential?
1847 </title>
1848
1849 <para>
1850 What has this to do with <emphasis>existential</emphasis> quantification?
1851 Simply that <function>MkFoo</function> has the (nearly) isomorphic type
1852 </para>
1853
1854 <para>
1855
1856 <programlisting>
1857   MkFoo :: (exists a . (a, a -> Bool)) -> Foo
1858 </programlisting>
1859
1860 </para>
1861
1862 <para>
1863 But Haskell programmers can safely think of the ordinary
1864 <emphasis>universally</emphasis> quantified type given above, thereby avoiding
1865 adding a new existential quantification construct.
1866 </para>
1867
1868 </sect2>
1869
1870 <sect2>
1871 <title>Type classes</title>
1872
1873 <para>
1874 An easy extension (implemented in <Command>hbc</Command>) is to allow
1875 arbitrary contexts before the constructor.  For example:
1876 </para>
1877
1878 <para>
1879
1880 <programlisting>
1881 data Baz = forall a. Eq a => Baz1 a a
1882          | forall b. Show b => Baz2 b (b -> b)
1883 </programlisting>
1884
1885 </para>
1886
1887 <para>
1888 The two constructors have the types you'd expect:
1889 </para>
1890
1891 <para>
1892
1893 <programlisting>
1894 Baz1 :: forall a. Eq a => a -> a -> Baz
1895 Baz2 :: forall b. Show b => b -> (b -> b) -> Baz
1896 </programlisting>
1897
1898 </para>
1899
1900 <para>
1901 But when pattern matching on <function>Baz1</function> the matched values can be compared
1902 for equality, and when pattern matching on <function>Baz2</function> the first matched
1903 value can be converted to a string (as well as applying the function to it).
1904 So this program is legal:
1905 </para>
1906
1907 <para>
1908
1909 <programlisting>
1910   f :: Baz -> String
1911   f (Baz1 p q) | p == q    = "Yes"
1912                | otherwise = "No"
1913   f (Baz1 v fn)            = show (fn v)
1914 </programlisting>
1915
1916 </para>
1917
1918 <para>
1919 Operationally, in a dictionary-passing implementation, the
1920 constructors <function>Baz1</function> and <function>Baz2</function> must store the
1921 dictionaries for <literal>Eq</literal> and <literal>Show</literal> respectively, and
1922 extract it on pattern matching.
1923 </para>
1924
1925 <para>
1926 Notice the way that the syntax fits smoothly with that used for
1927 universal quantification earlier.
1928 </para>
1929
1930 </sect2>
1931
1932 <sect2>
1933 <title>Restrictions</title>
1934
1935 <para>
1936 There are several restrictions on the ways in which existentially-quantified
1937 constructors can be use.
1938 </para>
1939
1940 <para>
1941
1942 <itemizedlist>
1943 <listitem>
1944
1945 <para>
1946  When pattern matching, each pattern match introduces a new,
1947 distinct, type for each existential type variable.  These types cannot
1948 be unified with any other type, nor can they escape from the scope of
1949 the pattern match.  For example, these fragments are incorrect:
1950
1951
1952 <programlisting>
1953 f1 (MkFoo a f) = a
1954 </programlisting>
1955
1956
1957 Here, the type bound by <function>MkFoo</function> "escapes", because <literal>a</literal>
1958 is the result of <function>f1</function>.  One way to see why this is wrong is to
1959 ask what type <function>f1</function> has:
1960
1961
1962 <programlisting>
1963   f1 :: Foo -> a             -- Weird!
1964 </programlisting>
1965
1966
1967 What is this "<literal>a</literal>" in the result type? Clearly we don't mean
1968 this:
1969
1970
1971 <programlisting>
1972   f1 :: forall a. Foo -> a   -- Wrong!
1973 </programlisting>
1974
1975
1976 The original program is just plain wrong.  Here's another sort of error
1977
1978
1979 <programlisting>
1980   f2 (Baz1 a b) (Baz1 p q) = a==q
1981 </programlisting>
1982
1983
1984 It's ok to say <literal>a==b</literal> or <literal>p==q</literal>, but
1985 <literal>a==q</literal> is wrong because it equates the two distinct types arising
1986 from the two <function>Baz1</function> constructors.
1987
1988
1989 </para>
1990 </listitem>
1991 <listitem>
1992
1993 <para>
1994 You can't pattern-match on an existentially quantified
1995 constructor in a <literal>let</literal> or <literal>where</literal> group of
1996 bindings. So this is illegal:
1997
1998
1999 <programlisting>
2000   f3 x = a==b where { Baz1 a b = x }
2001 </programlisting>
2002
2003
2004 You can only pattern-match
2005 on an existentially-quantified constructor in a <literal>case</literal> expression or
2006 in the patterns of a function definition.
2007
2008 The reason for this restriction is really an implementation one.
2009 Type-checking binding groups is already a nightmare without
2010 existentials complicating the picture.  Also an existential pattern
2011 binding at the top level of a module doesn't make sense, because it's
2012 not clear how to prevent the existentially-quantified type "escaping".
2013 So for now, there's a simple-to-state restriction.  We'll see how
2014 annoying it is.
2015
2016 </para>
2017 </listitem>
2018 <listitem>
2019
2020 <para>
2021 You can't use existential quantification for <literal>newtype</literal>
2022 declarations.  So this is illegal:
2023
2024
2025 <programlisting>
2026   newtype T = forall a. Ord a => MkT a
2027 </programlisting>
2028
2029
2030 Reason: a value of type <literal>T</literal> must be represented as a pair
2031 of a dictionary for <literal>Ord t</literal> and a value of type <literal>t</literal>.
2032 That contradicts the idea that <literal>newtype</literal> should have no
2033 concrete representation.  You can get just the same efficiency and effect
2034 by using <literal>data</literal> instead of <literal>newtype</literal>.  If there is no
2035 overloading involved, then there is more of a case for allowing
2036 an existentially-quantified <literal>newtype</literal>, because the <literal>data</literal>
2037 because the <literal>data</literal> version does carry an implementation cost,
2038 but single-field existentially quantified constructors aren't much
2039 use.  So the simple restriction (no existential stuff on <literal>newtype</literal>)
2040 stands, unless there are convincing reasons to change it.
2041
2042
2043 </para>
2044 </listitem>
2045 <listitem>
2046
2047 <para>
2048  You can't use <literal>deriving</literal> to define instances of a
2049 data type with existentially quantified data constructors.
2050
2051 Reason: in most cases it would not make sense. For example:&num;
2052
2053 <programlisting>
2054 data T = forall a. MkT [a] deriving( Eq )
2055 </programlisting>
2056
2057 To derive <literal>Eq</literal> in the standard way we would need to have equality
2058 between the single component of two <function>MkT</function> constructors:
2059
2060 <programlisting>
2061 instance Eq T where
2062   (MkT a) == (MkT b) = ???
2063 </programlisting>
2064
2065 But <VarName>a</VarName> and <VarName>b</VarName> have distinct types, and so can't be compared.
2066 It's just about possible to imagine examples in which the derived instance
2067 would make sense, but it seems altogether simpler simply to prohibit such
2068 declarations.  Define your own instances!
2069 </para>
2070 </listitem>
2071
2072 </itemizedlist>
2073
2074 </para>
2075
2076 </sect2>
2077
2078 </sect1>
2079
2080 <sect1 id="sec-assertions">
2081 <title>Assertions
2082 <indexterm><primary>Assertions</primary></indexterm>
2083 </title>
2084
2085 <para>
2086 If you want to make use of assertions in your standard Haskell code, you
2087 could define a function like the following:
2088 </para>
2089
2090 <para>
2091
2092 <programlisting>
2093 assert :: Bool -> a -> a
2094 assert False x = error "assertion failed!"
2095 assert _     x = x
2096 </programlisting>
2097
2098 </para>
2099
2100 <para>
2101 which works, but gives you back a less than useful error message --
2102 an assertion failed, but which and where?
2103 </para>
2104
2105 <para>
2106 One way out is to define an extended <function>assert</function> function which also
2107 takes a descriptive string to include in the error message and
2108 perhaps combine this with the use of a pre-processor which inserts
2109 the source location where <function>assert</function> was used.
2110 </para>
2111
2112 <para>
2113 Ghc offers a helping hand here, doing all of this for you. For every
2114 use of <function>assert</function> in the user's source:
2115 </para>
2116
2117 <para>
2118
2119 <programlisting>
2120 kelvinToC :: Double -> Double
2121 kelvinToC k = assert (k &gt;= 0.0) (k+273.15)
2122 </programlisting>
2123
2124 </para>
2125
2126 <para>
2127 Ghc will rewrite this to also include the source location where the
2128 assertion was made,
2129 </para>
2130
2131 <para>
2132
2133 <programlisting>
2134 assert pred val ==> assertError "Main.hs|15" pred val
2135 </programlisting>
2136
2137 </para>
2138
2139 <para>
2140 The rewrite is only performed by the compiler when it spots
2141 applications of <function>Exception.assert</function>, so you can still define and
2142 use your own versions of <function>assert</function>, should you so wish. If not,
2143 import <literal>Exception</literal> to make use <function>assert</function> in your code.
2144 </para>
2145
2146 <para>
2147 To have the compiler ignore uses of assert, use the compiler option
2148 <option>-fignore-asserts</option>. <indexterm><primary>-fignore-asserts option</primary></indexterm> That is,
2149 expressions of the form <literal>assert pred e</literal> will be rewritten to <literal>e</literal>.
2150 </para>
2151
2152 <para>
2153 Assertion failures can be caught, see the documentation for the
2154 <literal>Exception</literal> library (<xref linkend="sec-Exception">)
2155 for the details.
2156 </para>
2157
2158 </sect1>
2159
2160 <sect1 id="scoped-type-variables">
2161 <title>Scoped Type Variables
2162 </title>
2163
2164 <para>
2165 A <emphasis>pattern type signature</emphasis> can introduce a <emphasis>scoped type
2166 variable</emphasis>.  For example
2167 </para>
2168
2169 <para>
2170
2171 <programlisting>
2172 f (xs::[a]) = ys ++ ys
2173            where
2174               ys :: [a]
2175               ys = reverse xs
2176 </programlisting>
2177
2178 </para>
2179
2180 <para>
2181 The pattern <literal>(xs::[a])</literal> includes a type signature for <VarName>xs</VarName>.
2182 This brings the type variable <literal>a</literal> into scope; it scopes over
2183 all the patterns and right hand sides for this equation for <function>f</function>.
2184 In particular, it is in scope at the type signature for <VarName>y</VarName>.
2185 </para>
2186
2187 <para>
2188  Pattern type signatures are completely orthogonal to ordinary, separate
2189 type signatures.  The two can be used independently or together.
2190 At ordinary type signatures, such as that for <VarName>ys</VarName>, any type variables
2191 mentioned in the type signature <emphasis>that are not in scope</emphasis> are
2192 implicitly universally quantified.  (If there are no type variables in
2193 scope, all type variables mentioned in the signature are universally
2194 quantified, which is just as in Haskell 98.)  In this case, since <VarName>a</VarName>
2195 is in scope, it is not universally quantified, so the type of <VarName>ys</VarName> is
2196 the same as that of <VarName>xs</VarName>.  In Haskell 98 it is not possible to declare
2197 a type for <VarName>ys</VarName>; a major benefit of scoped type variables is that
2198 it becomes possible to do so.
2199 </para>
2200
2201 <para>
2202 Scoped type variables are implemented in both GHC and Hugs.  Where the
2203 implementations differ from the specification below, those differences
2204 are noted.
2205 </para>
2206
2207 <para>
2208 So much for the basic idea.  Here are the details.
2209 </para>
2210
2211 <sect2>
2212 <title>What a pattern type signature means</title>
2213 <para>
2214 A type variable brought into scope by a pattern type signature is simply
2215 the name for a type.   The restriction they express is that all occurrences
2216 of the same name mean the same type.  For example:
2217 <programlisting>
2218   f :: [Int] -> Int -> Int
2219   f (xs::[a]) (y::a) = (head xs + y) :: a
2220 </programlisting>
2221 The pattern type signatures on the left hand side of
2222 <literal>f</literal> express the fact that <literal>xs</literal>
2223 must be a list of things of some type <literal>a</literal>; and that <literal>y</literal>
2224 must have this same type.  The type signature on the expression <literal>(head xs)</literal>
2225 specifies that this expression must have the same type <literal>a</literal>.
2226 <emphasis>There is no requirement that the type named by "<literal>a</literal>" is
2227 in fact a type variable</emphasis>.  Indeed, in this case, the type named by "<literal>a</literal>" is
2228 <literal>Int</literal>.  (This is a slight liberalisation from the original rather complex
2229 rules, which specified that a pattern-bound type variable should be universally quantified.)
2230 For example, all of these are legal:</para>
2231
2232 <programlisting>
2233   t (x::a) (y::a) = x+y*2
2234
2235   f (x::a) (y::b) = [x,y]       -- a unifies with b
2236
2237   g (x::a) = x + 1::Int         -- a unifies with Int
2238
2239   h x = let k (y::a) = [x,y]    -- a is free in the
2240         in k x                  -- environment
2241
2242   k (x::a) True    = ...        -- a unifies with Int
2243   k (x::Int) False = ...
2244
2245   w :: [b] -> [b]
2246   w (x::a) = x                  -- a unifies with [b]
2247 </programlisting>
2248
2249 </sect2>
2250
2251 <sect2>
2252 <title>Scope and implicit quantification</title>
2253
2254 <para>
2255
2256 <itemizedlist>
2257 <listitem>
2258
2259 <para>
2260 All the type variables mentioned in a pattern,
2261 that are not already in scope,
2262 are brought into scope by the pattern.  We describe this set as
2263 the <emphasis>type variables bound by the pattern</emphasis>.
2264 For example:
2265 <programlisting>
2266   f (x::a) = let g (y::(a,b)) = fst y
2267              in
2268              g (x,True)
2269 </programlisting>
2270 The pattern <literal>(x::a)</literal> brings the type variable
2271 <literal>a</literal> into scope, as well as the term 
2272 variable <literal>x</literal>.  The pattern <literal>(y::(a,b))</literal>
2273 contains an occurrence of the already-in-scope type variable <literal>a</literal>,
2274 and brings into scope the type variable <literal>b</literal>.
2275 </para>
2276 </listitem>
2277
2278 <listitem>
2279 <para>
2280  The type variables thus brought into scope may be mentioned
2281 in ordinary type signatures or pattern type signatures anywhere within
2282 their scope.
2283
2284 </para>
2285 </listitem>
2286
2287 <listitem>
2288 <para>
2289  In ordinary type signatures, any type variable mentioned in the
2290 signature that is in scope is <emphasis>not</emphasis> universally quantified.
2291
2292 </para>
2293 </listitem>
2294
2295 <listitem>
2296
2297 <para>
2298  Ordinary type signatures do not bring any new type variables
2299 into scope (except in the type signature itself!). So this is illegal:
2300
2301 <programlisting>
2302   f :: a -> a
2303   f x = x::a
2304 </programlisting>
2305
2306 It's illegal because <VarName>a</VarName> is not in scope in the body of <function>f</function>,
2307 so the ordinary signature <literal>x::a</literal> is equivalent to <literal>x::forall a.a</literal>;
2308 and that is an incorrect typing.
2309
2310 </para>
2311 </listitem>
2312
2313 <listitem>
2314 <para>
2315  There is no implicit universal quantification on pattern type
2316 signatures, nor may one write an explicit <literal>forall</literal> type in a pattern
2317 type signature.  The pattern type signature is a monotype.
2318
2319 </para>
2320 </listitem>
2321
2322 <listitem>
2323 <para>
2324
2325 The type variables in the head of a <literal>class</literal> or <literal>instance</literal> declaration
2326 scope over the methods defined in the <literal>where</literal> part.  For example:
2327
2328
2329 <programlisting>
2330   class C a where
2331     op :: [a] -> a
2332
2333     op xs = let ys::[a]
2334                 ys = reverse xs
2335             in
2336             head ys
2337 </programlisting>
2338
2339
2340 (Not implemented in Hugs yet, Dec 98).
2341 </para>
2342 </listitem>
2343
2344 </itemizedlist>
2345
2346 </para>
2347
2348 </sect2>
2349
2350 <sect2>
2351 <title>Result type signatures</title>
2352
2353 <para>
2354
2355 <itemizedlist>
2356 <listitem>
2357
2358 <para>
2359  The result type of a function can be given a signature,
2360 thus:
2361
2362
2363 <programlisting>
2364   f (x::a) :: [a] = [x,x,x]
2365 </programlisting>
2366
2367
2368 The final <literal>:: [a]</literal> after all the patterns gives a signature to the
2369 result type.  Sometimes this is the only way of naming the type variable
2370 you want:
2371
2372
2373 <programlisting>
2374   f :: Int -> [a] -> [a]
2375   f n :: ([a] -> [a]) = let g (x::a, y::a) = (y,x)
2376                         in \xs -> map g (reverse xs `zip` xs)
2377 </programlisting>
2378
2379
2380 </para>
2381 </listitem>
2382
2383 </itemizedlist>
2384
2385 </para>
2386
2387 <para>
2388 Result type signatures are not yet implemented in Hugs.
2389 </para>
2390
2391 </sect2>
2392
2393 <sect2>
2394 <title>Where a pattern type signature can occur</title>
2395
2396 <para>
2397 A pattern type signature can occur in any pattern, but there
2398 are restrictions on pattern bindings:
2399 <itemizedlist>
2400
2401 <listitem>
2402 <para>
2403 A pattern type signature can be on an arbitrary sub-pattern, not
2404 ust on a variable:
2405
2406
2407 <programlisting>
2408   f ((x,y)::(a,b)) = (y,x) :: (b,a)
2409 </programlisting>
2410
2411
2412 </para>
2413 </listitem>
2414 <listitem>
2415
2416 <para>
2417  Pattern type signatures, including the result part, can be used
2418 in lambda abstractions:
2419
2420 <programlisting>
2421   (\ (x::a, y) :: a -> x)
2422 </programlisting>
2423 </para>
2424 </listitem>
2425 <listitem>
2426
2427 <para>
2428  Pattern type signatures, including the result part, can be used
2429 in <literal>case</literal> expressions:
2430
2431
2432 <programlisting>
2433   case e of { (x::a, y) :: a -> x }
2434 </programlisting>
2435
2436 </para>
2437 </listitem>
2438
2439 <listitem>
2440 <para>
2441 To avoid ambiguity, the type after the &ldquo;<literal>::</literal>&rdquo; in a result
2442 pattern signature on a lambda or <literal>case</literal> must be atomic (i.e. a single
2443 token or a parenthesised type of some sort).  To see why,
2444 consider how one would parse this:
2445
2446
2447 <programlisting>
2448   \ x :: a -> b -> x
2449 </programlisting>
2450
2451
2452 </para>
2453 </listitem>
2454
2455 <listitem>
2456
2457 <para>
2458  Pattern type signatures can bind existential type variables.
2459 For example:
2460
2461
2462 <programlisting>
2463   data T = forall a. MkT [a]
2464
2465   f :: T -> T
2466   f (MkT [t::a]) = MkT t3
2467                  where
2468                    t3::[a] = [t,t,t]
2469 </programlisting>
2470
2471
2472 </para>
2473 </listitem>
2474
2475
2476 <listitem>
2477
2478 <para>
2479 Pattern type signatures that bind new type variables
2480 may not be used in pattern bindings at all.
2481 So this is illegal:
2482
2483
2484 <programlisting>
2485   f x = let (y, z::a) = x in ...
2486 </programlisting>
2487
2488
2489 But these are OK, because they do not bind fresh type variables:
2490
2491
2492 <programlisting>
2493   f1 x            = let (y, z::Int) = x in ...
2494   f2 (x::(Int,a)) = let (y, z::a)   = x in ...
2495 </programlisting>
2496
2497
2498 However a single variable is considered a degenerate function binding,
2499 rather than a degerate pattern binding, so this is permitted, even
2500 though it binds a type variable:
2501
2502
2503 <programlisting>
2504   f :: (b->b) = \(x::b) -> x
2505 </programlisting>
2506
2507
2508 </para>
2509 </listitem>
2510
2511 </itemizedlist>
2512
2513 Such degnerate function bindings do not fall under the monomorphism
2514 restriction.  Thus:
2515 </para>
2516
2517 <para>
2518
2519 <programlisting>
2520   g :: a -> a -> Bool = \x y. x==y
2521 </programlisting>
2522
2523 </para>
2524
2525 <para>
2526 Here <function>g</function> has type <literal>forall a. Eq a =&gt; a -&gt; a -&gt; Bool</literal>, just as if
2527 <function>g</function> had a separate type signature.  Lacking a type signature, <function>g</function>
2528 would get a monomorphic type.
2529 </para>
2530
2531 </sect2>
2532
2533
2534 </sect1>
2535
2536   <sect1 id="pragmas">
2537     <title>Pragmas</title>
2538
2539     <indexterm><primary>pragma</primary></indexterm>
2540
2541     <para>GHC supports several pragmas, or instructions to the
2542     compiler placed in the source code.  Pragmas don't normally affect
2543     the meaning of the program, but they might affect the efficiency
2544     of the generated code.</para>
2545
2546     <para>Pragmas all take the form
2547
2548 <literal>{-# <replaceable>word</replaceable> ... #-}</literal>  
2549
2550     where <replaceable>word</replaceable> indicates the type of
2551     pragma, and is followed optionally by information specific to that
2552     type of pragma.  Case is ignored in
2553     <replaceable>word</replaceable>.  The various values for
2554     <replaceable>word</replaceable> that GHC understands are described
2555     in the following sections; any pragma encountered with an
2556     unrecognised <replaceable>word</replaceable> is (silently)
2557     ignored.</para>
2558
2559 <sect2 id="inline-pragma">
2560 <title>INLINE pragma
2561
2562 <indexterm><primary>INLINE pragma</primary></indexterm>
2563 <indexterm><primary>pragma, INLINE</primary></indexterm></title>
2564
2565 <para>
2566 GHC (with <option>-O</option>, as always) tries to inline (or &ldquo;unfold&rdquo;)
2567 functions/values that are &ldquo;small enough,&rdquo; thus avoiding the call
2568 overhead and possibly exposing other more-wonderful optimisations.
2569 </para>
2570
2571 <para>
2572 You will probably see these unfoldings (in Core syntax) in your
2573 interface files.
2574 </para>
2575
2576 <para>
2577 Normally, if GHC decides a function is &ldquo;too expensive&rdquo; to inline, it
2578 will not do so, nor will it export that unfolding for other modules to
2579 use.
2580 </para>
2581
2582 <para>
2583 The sledgehammer you can bring to bear is the
2584 <literal>INLINE</literal><indexterm><primary>INLINE pragma</primary></indexterm> pragma, used thusly:
2585
2586 <programlisting>
2587 key_function :: Int -> String -> (Bool, Double)
2588
2589 #ifdef __GLASGOW_HASKELL__
2590 {-# INLINE key_function #-}
2591 #endif
2592 </programlisting>
2593
2594 (You don't need to do the C pre-processor carry-on unless you're going
2595 to stick the code through HBC&mdash;it doesn't like <literal>INLINE</literal> pragmas.)
2596 </para>
2597
2598 <para>
2599 The major effect of an <literal>INLINE</literal> pragma is to declare a function's
2600 &ldquo;cost&rdquo; to be very low.  The normal unfolding machinery will then be
2601 very keen to inline it.
2602 </para>
2603
2604 <para>
2605 An <literal>INLINE</literal> pragma for a function can be put anywhere its type
2606 signature could be put.
2607 </para>
2608
2609 <para>
2610 <literal>INLINE</literal> pragmas are a particularly good idea for the
2611 <literal>then</literal>/<literal>return</literal> (or <literal>bind</literal>/<literal>unit</literal>) functions in a monad.
2612 For example, in GHC's own <literal>UniqueSupply</literal> monad code, we have:
2613
2614 <programlisting>
2615 #ifdef __GLASGOW_HASKELL__
2616 {-# INLINE thenUs #-}
2617 {-# INLINE returnUs #-}
2618 #endif
2619 </programlisting>
2620
2621 </para>
2622
2623 </sect2>
2624
2625 <sect2 id="noinline-pragma">
2626 <title>NOINLINE pragma
2627 </title>
2628
2629 <indexterm><primary>NOINLINE pragma</primary></indexterm>
2630 <indexterm><primary>pragma</primary><secondary>NOINLINE</secondary></indexterm>
2631 <indexterm><primary>NOTINLINE pragma</primary></indexterm>
2632 <indexterm><primary>pragma</primary><secondary>NOTINLINE</secondary></indexterm>
2633
2634 <para>
2635 The <literal>NOINLINE</literal> pragma does exactly what you'd expect:
2636 it stops the named function from being inlined by the compiler.  You
2637 shouldn't ever need to do this, unless you're very cautious about code
2638 size.
2639 </para>
2640
2641 <para><literal>NOTINLINE</literal> is a synonym for
2642 <literal>NOINLINE</literal> (<literal>NOTINLINE</literal> is specified
2643 by Haskell 98 as the standard way to disable inlining, so it should be
2644 used if you want your code to be portable).</para>
2645
2646 </sect2>
2647
2648     <sect2 id="specialize-pragma">
2649       <title>SPECIALIZE pragma</title>
2650
2651       <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2652       <indexterm><primary>pragma, SPECIALIZE</primary></indexterm>
2653       <indexterm><primary>overloading, death to</primary></indexterm>
2654
2655       <para>(UK spelling also accepted.)  For key overloaded
2656       functions, you can create extra versions (NB: more code space)
2657       specialised to particular types.  Thus, if you have an
2658       overloaded function:</para>
2659
2660 <programlisting>
2661 hammeredLookup :: Ord key => [(key, value)] -> key -> value
2662 </programlisting>
2663
2664       <para>If it is heavily used on lists with
2665       <literal>Widget</literal> keys, you could specialise it as
2666       follows:</para>
2667
2668 <programlisting>
2669 {-# SPECIALIZE hammeredLookup :: [(Widget, value)] -> Widget -> value #-}
2670 </programlisting>
2671
2672       <para>To get very fancy, you can also specify a named function
2673       to use for the specialised value, as in:</para>
2674
2675 <programlisting>
2676 {-# RULES hammeredLookup = blah #-}
2677 </programlisting>
2678
2679       <para>where <literal>blah</literal> is an implementation of
2680       <literal>hammerdLookup</literal> written specialy for
2681       <literal>Widget</literal> lookups.  It's <emphasis>Your
2682       Responsibility</emphasis> to make sure that
2683       <function>blah</function> really behaves as a specialised
2684       version of <function>hammeredLookup</function>!!!</para>
2685
2686       <para>Note we use the <literal>RULE</literal> pragma here to
2687       indicate that <literal>hammeredLookup</literal> applied at a
2688       certain type should be replaced by <literal>blah</literal>.  See
2689       <xref linkend="rules"> for more information on
2690       <literal>RULES</literal>.</para>
2691
2692       <para>An example in which using <literal>RULES</literal> for
2693       specialisation will Win Big:
2694
2695 <programlisting>
2696 toDouble :: Real a => a -> Double
2697 toDouble = fromRational . toRational
2698
2699 {-# SPECIALIZE toDouble :: Int -> Double = i2d #-}
2700 i2d (I# i) = D# (int2Double# i) -- uses Glasgow prim-op directly
2701 </programlisting>
2702
2703       The <function>i2d</function> function is virtually one machine
2704       instruction; the default conversion&mdash;via an intermediate
2705       <literal>Rational</literal>&mdash;is obscenely expensive by
2706       comparison.</para>
2707
2708       <para>A <literal>SPECIALIZE</literal> pragma for a function can
2709       be put anywhere its type signature could be put.</para>
2710
2711     </sect2>
2712
2713 <sect2 id="specialize-instance-pragma">
2714 <title>SPECIALIZE instance pragma
2715 </title>
2716
2717 <para>
2718 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2719 <indexterm><primary>overloading, death to</primary></indexterm>
2720 Same idea, except for instance declarations.  For example:
2721
2722 <programlisting>
2723 instance (Eq a) => Eq (Foo a) where { ... usual stuff ... }
2724
2725 {-# SPECIALIZE instance Eq (Foo [(Int, Bar)] #-}
2726 </programlisting>
2727
2728 Compatible with HBC, by the way.
2729 </para>
2730
2731 </sect2>
2732
2733 <sect2 id="line-pragma">
2734 <title>LINE pragma
2735 </title>
2736
2737 <para>
2738 <indexterm><primary>LINE pragma</primary></indexterm>
2739 <indexterm><primary>pragma, LINE</primary></indexterm>
2740 </para>
2741
2742 <para>
2743 This pragma is similar to C's <literal>&num;line</literal> pragma, and is mainly for use in
2744 automatically generated Haskell code.  It lets you specify the line
2745 number and filename of the original code; for example
2746 </para>
2747
2748 <para>
2749
2750 <programlisting>
2751 {-# LINE 42 "Foo.vhs" #-}
2752 </programlisting>
2753
2754 </para>
2755
2756 <para>
2757 if you'd generated the current file from something called <filename>Foo.vhs</filename>
2758 and this line corresponds to line 42 in the original.  GHC will adjust
2759 its error messages to refer to the line/file named in the <literal>LINE</literal>
2760 pragma.
2761 </para>
2762
2763 </sect2>
2764
2765 <sect2 id="rules">
2766 <title>RULES pragma</title>
2767
2768 <para>
2769 The RULES pragma lets you specify rewrite rules.  It is described in
2770 <xref LinkEnd="rewrite-rules">.
2771 </para>
2772
2773 </sect2>
2774
2775 <sect2 id="deprecated-pragma">
2776 <title>DEPRECATED pragma</title>
2777
2778 <para>
2779 The DEPRECATED pragma lets you specify that a particular function, class, or type, is deprecated.  
2780 There are two forms.  
2781 </para>
2782 <itemizedlist>
2783 <listitem><para>
2784 You can deprecate an entire module thus:</para>
2785 <programlisting>
2786    module Wibble {-# DEPRECATED "Use Wobble instead" #-} where
2787      ...
2788 </programlisting>
2789 <para>
2790 When you compile any module that import <literal>Wibble</literal>, GHC will print
2791 the specified message.</para>
2792 </listitem>
2793
2794 <listitem>
2795 <para>
2796 You can deprecate a function, class, or type, with the following top-level declaration:
2797 </para>
2798 <programlisting>
2799    {-# DEPRECATED f, C, T "Don't use these" #-}
2800 </programlisting>
2801 <para>
2802 When you compile any module that imports and uses any of the specifed entities, 
2803 GHC will print the specified message.
2804 </para>
2805 </listitem>
2806 </itemizedlist>
2807 <para>You can suppress the warnings with the flag <option>-fno-warn-deprecations</option>.</para>
2808
2809 </sect2>
2810
2811 </sect1>
2812
2813 <sect1 id="rewrite-rules">
2814 <title>Rewrite rules
2815
2816 <indexterm><primary>RULES pagma</primary></indexterm>
2817 <indexterm><primary>pragma, RULES</primary></indexterm>
2818 <indexterm><primary>rewrite rules</primary></indexterm></title>
2819
2820 <para>
2821 The programmer can specify rewrite rules as part of the source program
2822 (in a pragma).  GHC applies these rewrite rules wherever it can.
2823 </para>
2824
2825 <para>
2826 Here is an example:
2827
2828 <programlisting>
2829   {-# RULES
2830         "map/map"       forall f g xs. map f (map g xs) = map (f.g) xs
2831   #-}
2832 </programlisting>
2833
2834 </para>
2835
2836 <sect2>
2837 <title>Syntax</title>
2838
2839 <para>
2840 From a syntactic point of view:
2841
2842 <itemizedlist>
2843 <listitem>
2844
2845 <para>
2846  Each rule has a name, enclosed in double quotes.  The name itself has
2847 no significance at all.  It is only used when reporting how many times the rule fired.
2848 </para>
2849 </listitem>
2850 <listitem>
2851
2852 <para>
2853  There may be zero or more rules in a <literal>RULES</literal> pragma.
2854 </para>
2855 </listitem>
2856 <listitem>
2857
2858 <para>
2859  Layout applies in a <literal>RULES</literal> pragma.  Currently no new indentation level
2860 is set, so you must lay out your rules starting in the same column as the
2861 enclosing definitions.
2862 </para>
2863 </listitem>
2864 <listitem>
2865
2866 <para>
2867  Each variable mentioned in a rule must either be in scope (e.g. <function>map</function>),
2868 or bound by the <literal>forall</literal> (e.g. <function>f</function>, <function>g</function>, <function>xs</function>).  The variables bound by
2869 the <literal>forall</literal> are called the <emphasis>pattern</emphasis> variables.  They are separated
2870 by spaces, just like in a type <literal>forall</literal>.
2871 </para>
2872 </listitem>
2873 <listitem>
2874
2875 <para>
2876  A pattern variable may optionally have a type signature.
2877 If the type of the pattern variable is polymorphic, it <emphasis>must</emphasis> have a type signature.
2878 For example, here is the <literal>foldr/build</literal> rule:
2879
2880 <programlisting>
2881 "fold/build"  forall k z (g::forall b. (a->b->b) -> b -> b) .
2882               foldr k z (build g) = g k z
2883 </programlisting>
2884
2885 Since <function>g</function> has a polymorphic type, it must have a type signature.
2886
2887 </para>
2888 </listitem>
2889 <listitem>
2890
2891 <para>
2892 The left hand side of a rule must consist of a top-level variable applied
2893 to arbitrary expressions.  For example, this is <emphasis>not</emphasis> OK:
2894
2895 <programlisting>
2896 "wrong1"   forall e1 e2.  case True of { True -> e1; False -> e2 } = e1
2897 "wrong2"   forall f.      f True = True
2898 </programlisting>
2899
2900 In <literal>"wrong1"</literal>, the LHS is not an application; in <literal>"wrong2"</literal>, the LHS has a pattern variable
2901 in the head.
2902 </para>
2903 </listitem>
2904 <listitem>
2905
2906 <para>
2907  A rule does not need to be in the same module as (any of) the
2908 variables it mentions, though of course they need to be in scope.
2909 </para>
2910 </listitem>
2911 <listitem>
2912
2913 <para>
2914  Rules are automatically exported from a module, just as instance declarations are.
2915 </para>
2916 </listitem>
2917
2918 </itemizedlist>
2919
2920 </para>
2921
2922 </sect2>
2923
2924 <sect2>
2925 <title>Semantics</title>
2926
2927 <para>
2928 From a semantic point of view:
2929
2930 <itemizedlist>
2931 <listitem>
2932
2933 <para>
2934 Rules are only applied if you use the <option>-O</option> flag.
2935 </para>
2936 </listitem>
2937
2938 <listitem>
2939 <para>
2940  Rules are regarded as left-to-right rewrite rules.
2941 When GHC finds an expression that is a substitution instance of the LHS
2942 of a rule, it replaces the expression by the (appropriately-substituted) RHS.
2943 By "a substitution instance" we mean that the LHS can be made equal to the
2944 expression by substituting for the pattern variables.
2945
2946 </para>
2947 </listitem>
2948 <listitem>
2949
2950 <para>
2951  The LHS and RHS of a rule are typechecked, and must have the
2952 same type.
2953
2954 </para>
2955 </listitem>
2956 <listitem>
2957
2958 <para>
2959  GHC makes absolutely no attempt to verify that the LHS and RHS
2960 of a rule have the same meaning.  That is undecideable in general, and
2961 infeasible in most interesting cases.  The responsibility is entirely the programmer's!
2962
2963 </para>
2964 </listitem>
2965 <listitem>
2966
2967 <para>
2968  GHC makes no attempt to make sure that the rules are confluent or
2969 terminating.  For example:
2970
2971 <programlisting>
2972   "loop"        forall x,y.  f x y = f y x
2973 </programlisting>
2974
2975 This rule will cause the compiler to go into an infinite loop.
2976
2977 </para>
2978 </listitem>
2979 <listitem>
2980
2981 <para>
2982  If more than one rule matches a call, GHC will choose one arbitrarily to apply.
2983
2984 </para>
2985 </listitem>
2986 <listitem>
2987 <para>
2988  GHC currently uses a very simple, syntactic, matching algorithm
2989 for matching a rule LHS with an expression.  It seeks a substitution
2990 which makes the LHS and expression syntactically equal modulo alpha
2991 conversion.  The pattern (rule), but not the expression, is eta-expanded if
2992 necessary.  (Eta-expanding the epression can lead to laziness bugs.)
2993 But not beta conversion (that's called higher-order matching).
2994 </para>
2995
2996 <para>
2997 Matching is carried out on GHC's intermediate language, which includes
2998 type abstractions and applications.  So a rule only matches if the
2999 types match too.  See <xref LinkEnd="rule-spec"> below.
3000 </para>
3001 </listitem>
3002 <listitem>
3003
3004 <para>
3005  GHC keeps trying to apply the rules as it optimises the program.
3006 For example, consider:
3007
3008 <programlisting>
3009   let s = map f
3010       t = map g
3011   in
3012   s (t xs)
3013 </programlisting>
3014
3015 The expression <literal>s (t xs)</literal> does not match the rule <literal>"map/map"</literal>, but GHC
3016 will substitute for <VarName>s</VarName> and <VarName>t</VarName>, giving an expression which does match.
3017 If <VarName>s</VarName> or <VarName>t</VarName> was (a) used more than once, and (b) large or a redex, then it would
3018 not be substituted, and the rule would not fire.
3019
3020 </para>
3021 </listitem>
3022 <listitem>
3023
3024 <para>
3025  In the earlier phases of compilation, GHC inlines <emphasis>nothing
3026 that appears on the LHS of a rule</emphasis>, because once you have substituted
3027 for something you can't match against it (given the simple minded
3028 matching).  So if you write the rule
3029
3030 <programlisting>
3031         "map/map"       forall f,g.  map f . map g = map (f.g)
3032 </programlisting>
3033
3034 this <emphasis>won't</emphasis> match the expression <literal>map f (map g xs)</literal>.
3035 It will only match something written with explicit use of ".".
3036 Well, not quite.  It <emphasis>will</emphasis> match the expression
3037
3038 <programlisting>
3039 wibble f g xs
3040 </programlisting>
3041
3042 where <function>wibble</function> is defined:
3043
3044 <programlisting>
3045 wibble f g = map f . map g
3046 </programlisting>
3047
3048 because <function>wibble</function> will be inlined (it's small).
3049
3050 Later on in compilation, GHC starts inlining even things on the
3051 LHS of rules, but still leaves the rules enabled.  This inlining
3052 policy is controlled by the per-simplification-pass flag <option>-finline-phase</option><emphasis>n</emphasis>.
3053
3054 </para>
3055 </listitem>
3056 <listitem>
3057
3058 <para>
3059  All rules are implicitly exported from the module, and are therefore
3060 in force in any module that imports the module that defined the rule, directly
3061 or indirectly.  (That is, if A imports B, which imports C, then C's rules are
3062 in force when compiling A.)  The situation is very similar to that for instance
3063 declarations.
3064 </para>
3065 </listitem>
3066
3067 </itemizedlist>
3068
3069 </para>
3070
3071 </sect2>
3072
3073 <sect2>
3074 <title>List fusion</title>
3075
3076 <para>
3077 The RULES mechanism is used to implement fusion (deforestation) of common list functions.
3078 If a "good consumer" consumes an intermediate list constructed by a "good producer", the
3079 intermediate list should be eliminated entirely.
3080 </para>
3081
3082 <para>
3083 The following are good producers:
3084
3085 <itemizedlist>
3086 <listitem>
3087
3088 <para>
3089  List comprehensions
3090 </para>
3091 </listitem>
3092 <listitem>
3093
3094 <para>
3095  Enumerations of <literal>Int</literal> and <literal>Char</literal> (e.g. <literal>['a'..'z']</literal>).
3096 </para>
3097 </listitem>
3098 <listitem>
3099
3100 <para>
3101  Explicit lists (e.g. <literal>[True, False]</literal>)
3102 </para>
3103 </listitem>
3104 <listitem>
3105
3106 <para>
3107  The cons constructor (e.g <literal>3:4:[]</literal>)
3108 </para>
3109 </listitem>
3110 <listitem>
3111
3112 <para>
3113  <function>++</function>
3114 </para>
3115 </listitem>
3116 <listitem>
3117
3118 <para>
3119  <function>map</function>
3120 </para>
3121 </listitem>
3122 <listitem>
3123
3124 <para>
3125  <function>filter</function>
3126 </para>
3127 </listitem>
3128 <listitem>
3129
3130 <para>
3131  <function>iterate</function>, <function>repeat</function>
3132 </para>
3133 </listitem>
3134 <listitem>
3135
3136 <para>
3137  <function>zip</function>, <function>zipWith</function>
3138 </para>
3139 </listitem>
3140
3141 </itemizedlist>
3142
3143 </para>
3144
3145 <para>
3146 The following are good consumers:
3147
3148 <itemizedlist>
3149 <listitem>
3150
3151 <para>
3152  List comprehensions
3153 </para>
3154 </listitem>
3155 <listitem>
3156
3157 <para>
3158  <function>array</function> (on its second argument)
3159 </para>
3160 </listitem>
3161 <listitem>
3162
3163 <para>
3164  <function>length</function>
3165 </para>
3166 </listitem>
3167 <listitem>
3168
3169 <para>
3170  <function>++</function> (on its first argument)
3171 </para>
3172 </listitem>
3173 <listitem>
3174
3175 <para>
3176  <function>map</function>
3177 </para>
3178 </listitem>
3179 <listitem>
3180
3181 <para>
3182  <function>filter</function>
3183 </para>
3184 </listitem>
3185 <listitem>
3186
3187 <para>
3188  <function>concat</function>
3189 </para>
3190 </listitem>
3191 <listitem>
3192
3193 <para>
3194  <function>unzip</function>, <function>unzip2</function>, <function>unzip3</function>, <function>unzip4</function>
3195 </para>
3196 </listitem>
3197 <listitem>
3198
3199 <para>
3200  <function>zip</function>, <function>zipWith</function> (but on one argument only; if both are good producers, <function>zip</function>
3201 will fuse with one but not the other)
3202 </para>
3203 </listitem>
3204 <listitem>
3205
3206 <para>
3207  <function>partition</function>
3208 </para>
3209 </listitem>
3210 <listitem>
3211
3212 <para>
3213  <function>head</function>
3214 </para>
3215 </listitem>
3216 <listitem>
3217
3218 <para>
3219  <function>and</function>, <function>or</function>, <function>any</function>, <function>all</function>
3220 </para>
3221 </listitem>
3222 <listitem>
3223
3224 <para>
3225  <function>sequence&lowbar;</function>
3226 </para>
3227 </listitem>
3228 <listitem>
3229
3230 <para>
3231  <function>msum</function>
3232 </para>
3233 </listitem>
3234 <listitem>
3235
3236 <para>
3237  <function>sortBy</function>
3238 </para>
3239 </listitem>
3240
3241 </itemizedlist>
3242
3243 </para>
3244
3245 <para>
3246 So, for example, the following should generate no intermediate lists:
3247
3248 <programlisting>
3249 array (1,10) [(i,i*i) | i &#60;- map (+ 1) [0..9]]
3250 </programlisting>
3251
3252 </para>
3253
3254 <para>
3255 This list could readily be extended; if there are Prelude functions that you use
3256 a lot which are not included, please tell us.
3257 </para>
3258
3259 <para>
3260 If you want to write your own good consumers or producers, look at the
3261 Prelude definitions of the above functions to see how to do so.
3262 </para>
3263
3264 </sect2>
3265
3266 <sect2 id="rule-spec">
3267 <title>Specialisation
3268 </title>
3269
3270 <para>
3271 Rewrite rules can be used to get the same effect as a feature
3272 present in earlier version of GHC:
3273
3274 <programlisting>
3275   {-# SPECIALIZE fromIntegral :: Int8 -> Int16 = int8ToInt16 #-}
3276 </programlisting>
3277
3278 This told GHC to use <function>int8ToInt16</function> instead of <function>fromIntegral</function> whenever
3279 the latter was called with type <literal>Int8 -&gt; Int16</literal>.  That is, rather than
3280 specialising the original definition of <function>fromIntegral</function> the programmer is
3281 promising that it is safe to use <function>int8ToInt16</function> instead.
3282 </para>
3283
3284 <para>
3285 This feature is no longer in GHC.  But rewrite rules let you do the
3286 same thing:
3287
3288 <programlisting>
3289 {-# RULES
3290   "fromIntegral/Int8/Int16" fromIntegral = int8ToInt16
3291 #-}
3292 </programlisting>
3293
3294 This slightly odd-looking rule instructs GHC to replace <function>fromIntegral</function>
3295 by <function>int8ToInt16</function> <emphasis>whenever the types match</emphasis>.  Speaking more operationally,
3296 GHC adds the type and dictionary applications to get the typed rule
3297
3298 <programlisting>
3299 forall (d1::Integral Int8) (d2::Num Int16) .
3300         fromIntegral Int8 Int16 d1 d2 = int8ToInt16
3301 </programlisting>
3302
3303 What is more,
3304 this rule does not need to be in the same file as fromIntegral,
3305 unlike the <literal>SPECIALISE</literal> pragmas which currently do (so that they
3306 have an original definition available to specialise).
3307 </para>
3308
3309 </sect2>
3310
3311 <sect2>
3312 <title>Controlling what's going on</title>
3313
3314 <para>
3315
3316 <itemizedlist>
3317 <listitem>
3318
3319 <para>
3320  Use <option>-ddump-rules</option> to see what transformation rules GHC is using.
3321 </para>
3322 </listitem>
3323 <listitem>
3324
3325 <para>
3326  Use <option>-ddump-simpl-stats</option> to see what rules are being fired.
3327 If you add <option>-dppr-debug</option> you get a more detailed listing.
3328 </para>
3329 </listitem>
3330 <listitem>
3331
3332 <para>
3333  The defintion of (say) <function>build</function> in <FileName>PrelBase.lhs</FileName> looks llike this:
3334
3335 <programlisting>
3336         build   :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
3337         {-# INLINE build #-}
3338         build g = g (:) []
3339 </programlisting>
3340
3341 Notice the <literal>INLINE</literal>!  That prevents <literal>(:)</literal> from being inlined when compiling
3342 <literal>PrelBase</literal>, so that an importing module will &ldquo;see&rdquo; the <literal>(:)</literal>, and can
3343 match it on the LHS of a rule.  <literal>INLINE</literal> prevents any inlining happening
3344 in the RHS of the <literal>INLINE</literal> thing.  I regret the delicacy of this.
3345
3346 </para>
3347 </listitem>
3348 <listitem>
3349
3350 <para>
3351  In <filename>ghc/lib/std/PrelBase.lhs</filename> look at the rules for <function>map</function> to
3352 see how to write rules that will do fusion and yet give an efficient
3353 program even if fusion doesn't happen.  More rules in <filename>PrelList.lhs</filename>.
3354 </para>
3355 </listitem>
3356
3357 </itemizedlist>
3358
3359 </para>
3360
3361 </sect2>
3362
3363 </sect1>
3364
3365 <sect1 id="generic-classes">
3366 <title>Generic classes</title>
3367
3368 <para>
3369 The ideas behind this extension are described in detail in "Derivable type classes",
3370 Ralf Hinze and Simon Peyton Jones, Haskell Workshop, Montreal Sept 2000, pp94-105.
3371 An example will give the idea:
3372 </para>
3373
3374 <programlisting>
3375   import Generics
3376
3377   class Bin a where
3378     toBin   :: a -> [Int]
3379     fromBin :: [Int] -> (a, [Int])
3380   
3381     toBin {| Unit |}    Unit      = []
3382     toBin {| a :+: b |} (Inl x)   = 0 : toBin x
3383     toBin {| a :+: b |} (Inr y)   = 1 : toBin y
3384     toBin {| a :*: b |} (x :*: y) = toBin x ++ toBin y
3385   
3386     fromBin {| Unit |}    bs      = (Unit, bs)
3387     fromBin {| a :+: b |} (0:bs)  = (Inl x, bs')    where (x,bs') = fromBin bs
3388     fromBin {| a :+: b |} (1:bs)  = (Inr y, bs')    where (y,bs') = fromBin bs
3389     fromBin {| a :*: b |} bs      = (x :*: y, bs'') where (x,bs' ) = fromBin bs
3390                                                           (y,bs'') = fromBin bs'
3391 </programlisting>
3392 <para>
3393 This class declaration explains how <literal>toBin</literal> and <literal>fromBin</literal>
3394 work for arbitrary data types.  They do so by giving cases for unit, product, and sum,
3395 which are defined thus in the library module <literal>Generics</literal>:
3396 </para>
3397 <programlisting>
3398   data Unit    = Unit
3399   data a :+: b = Inl a | Inr b
3400   data a :*: b = a :*: b
3401 </programlisting>
3402 <para>
3403 Now you can make a data type into an instance of Bin like this:
3404 <programlisting>
3405   instance (Bin a, Bin b) => Bin (a,b)
3406   instance Bin a => Bin [a]
3407 </programlisting>
3408 That is, just leave off the "where" clasuse.  Of course, you can put in the
3409 where clause and over-ride whichever methods you please.
3410 </para>
3411
3412     <sect2>
3413       <title> Using generics </title>
3414       <para>To use generics you need to</para>
3415       <itemizedlist>
3416         <listitem>
3417           <para>Use the flags <option>-fglasgow-exts</option> (to enable the extra syntax), 
3418                 <option>-fgenerics</option> (to generate extra per-data-type code),
3419                 and <option>-package lang</option> (to make the <literal>Generics</literal> library
3420                 available.  </para>
3421         </listitem>
3422         <listitem>
3423           <para>Import the module <literal>Generics</literal> from the
3424           <literal>lang</literal> package.  This import brings into
3425           scope the data types <literal>Unit</literal>,
3426           <literal>:*:</literal>, and <literal>:+:</literal>.  (You
3427           don't need this import if you don't mention these types
3428           explicitly; for example, if you are simply giving instance
3429           declarations.)</para>
3430         </listitem>
3431       </itemizedlist>
3432     </sect2>
3433
3434 <sect2> <title> Changes wrt the paper </title>
3435 <para>
3436 Note that the type constructors <literal>:+:</literal> and <literal>:*:</literal> 
3437 can be written infix (indeed, you can now use
3438 any operator starting in a colon as an infix type constructor).  Also note that
3439 the type constructors are not exactly as in the paper (Unit instead of 1, etc).
3440 Finally, note that the syntax of the type patterns in the class declaration
3441 uses "<literal>{|</literal>" and "<literal>|}</literal>" brackets; curly braces
3442 alone would ambiguous when they appear on right hand sides (an extension we 
3443 anticipate wanting).
3444 </para>
3445 </sect2>
3446
3447 <sect2> <title>Terminology and restrictions</title>
3448 <para>
3449 Terminology.  A "generic default method" in a class declaration
3450 is one that is defined using type patterns as above.
3451 A "polymorphic default method" is a default method defined as in Haskell 98.
3452 A "generic class declaration" is a class declaration with at least one
3453 generic default method.
3454 </para>
3455
3456 <para>
3457 Restrictions:
3458 <itemizedlist>
3459 <listitem>
3460 <para>
3461 Alas, we do not yet implement the stuff about constructor names and 
3462 field labels.
3463 </para>
3464 </listitem>
3465
3466 <listitem>
3467 <para>
3468 A generic class can have only one parameter; you can't have a generic
3469 multi-parameter class.
3470 </para>
3471 </listitem>
3472
3473 <listitem>
3474 <para>
3475 A default method must be defined entirely using type patterns, or entirely
3476 without.  So this is illegal:
3477 <programlisting>
3478   class Foo a where
3479     op :: a -> (a, Bool)
3480     op {| Unit |} Unit = (Unit, True)
3481     op x               = (x,    False)
3482 </programlisting>
3483 However it is perfectly OK for some methods of a generic class to have 
3484 generic default methods and others to have polymorphic default methods.
3485 </para>
3486 </listitem>
3487
3488 <listitem>
3489 <para>
3490 The type variable(s) in the type pattern for a generic method declaration
3491 scope over the right hand side.  So this is legal (note the use of the type variable ``p'' in a type signature on the right hand side:
3492 <programlisting>
3493   class Foo a where
3494     op :: a -> Bool
3495     op {| p :*: q |} (x :*: y) = op (x :: p)
3496     ...
3497 </programlisting>
3498 </para>
3499 </listitem>
3500
3501 <listitem>
3502 <para>
3503 The type patterns in a generic default method must take one of the forms:
3504 <programlisting>
3505        a :+: b
3506        a :*: b
3507        Unit
3508 </programlisting>
3509 where "a" and "b" are type variables.  Furthermore, all the type patterns for
3510 a single type constructor (<literal>:*:</literal>, say) must be identical; they
3511 must use the same type variables.  So this is illegal:
3512 <programlisting>
3513   class Foo a where
3514     op :: a -> Bool
3515     op {| a :+: b |} (Inl x) = True
3516     op {| p :+: q |} (Inr y) = False
3517 </programlisting>
3518 The type patterns must be identical, even in equations for different methods of the class.
3519 So this too is illegal:
3520 <programlisting>
3521   class Foo a where
3522     op1 :: a -> Bool
3523     op {| a :*: b |} (Inl x) = True
3524
3525     op2 :: a -> Bool
3526     op {| p :*: q |} (Inr y) = False
3527 </programlisting>
3528 (The reason for this restriction is that we gather all the equations for a particular type consructor
3529 into a single generic instance declaration.)
3530 </para>
3531 </listitem>
3532
3533 <listitem>
3534 <para>
3535 A generic method declaration must give a case for each of the three type constructors.
3536 </para>
3537 </listitem>
3538
3539 <listitem>
3540 <para>
3541 The type for a generic method can be built only from:
3542   <itemizedlist>
3543   <listitem> <para> Function arrows </para> </listitem>
3544   <listitem> <para> Type variables </para> </listitem>
3545   <listitem> <para> Tuples </para> </listitem>
3546   <listitem> <para> Arbitrary types not involving type variables </para> </listitem>
3547   </itemizedlist>
3548 Here are some example type signatures for generic methods:
3549 <programlisting>
3550     op1 :: a -> Bool
3551     op2 :: Bool -> (a,Bool)
3552     op3 :: [Int] -> a -> a
3553     op4 :: [a] -> Bool
3554 </programlisting>
3555 Here, op1, op2, op3 are OK, but op4 is rejected, because it has a type variable
3556 inside a list.  
3557 </para>
3558 <para>
3559 This restriction is an implementation restriction: we just havn't got around to
3560 implementing the necessary bidirectional maps over arbitrary type constructors.
3561 It would be relatively easy to add specific type constructors, such as Maybe and list,
3562 to the ones that are allowed.</para>
3563 </listitem>
3564
3565 <listitem>
3566 <para>
3567 In an instance declaration for a generic class, the idea is that the compiler
3568 will fill in the methods for you, based on the generic templates.  However it can only
3569 do so if
3570   <itemizedlist>
3571   <listitem>
3572   <para>
3573   The instance type is simple (a type constructor applied to type variables, as in Haskell 98).
3574   </para>
3575   </listitem>
3576   <listitem>
3577   <para>
3578   No constructor of the instance type has unboxed fields.
3579   </para>
3580   </listitem>
3581   </itemizedlist>
3582 (Of course, these things can only arise if you are already using GHC extensions.)
3583 However, you can still give an instance declarations for types which break these rules,
3584 provided you give explicit code to override any generic default methods.
3585 </para>
3586 </listitem>
3587
3588 </itemizedlist>
3589 </para>
3590
3591 <para>
3592 The option <option>-ddump-deriv</option> dumps incomprehensible stuff giving details of 
3593 what the compiler does with generic declarations.
3594 </para>
3595
3596 </sect2>
3597
3598 <sect2> <title> Another example </title>
3599 <para>
3600 Just to finish with, here's another example I rather like:
3601 <programlisting>
3602   class Tag a where
3603     nCons :: a -> Int
3604     nCons {| Unit |}    _ = 1
3605     nCons {| a :*: b |} _ = 1
3606     nCons {| a :+: b |} _ = nCons (bot::a) + nCons (bot::b)
3607   
3608     tag :: a -> Int
3609     tag {| Unit |}    _       = 1
3610     tag {| a :*: b |} _       = 1   
3611     tag {| a :+: b |} (Inl x) = tag x
3612     tag {| a :+: b |} (Inr y) = nCons (bot::a) + tag y
3613 </programlisting>
3614 </para>
3615 </sect2>
3616 </sect1>
3617
3618 <!-- Emacs stuff:
3619      ;;; Local Variables: ***
3620      ;;; mode: sgml ***
3621      ;;; sgml-parent-document: ("users_guide.sgml" "book" "chapter" "sect1") ***
3622      ;;; End: ***
3623  -->