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