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