4b1c7a1d83afcfbdceb5c154b84079232bc091a9
[ghc-hetmet.git] / docs / users_guide / glasgow_exts.xml
1 <?xml version="1.0" encoding="iso-8859-1"?>
2 <para>
3 <indexterm><primary>language, GHC</primary></indexterm>
4 <indexterm><primary>extensions, GHC</primary></indexterm>
5 As with all known Haskell systems, GHC implements some extensions to
6 the language.  They are all enabled by options; by default GHC
7 understands only plain Haskell 98.
8 </para>
9
10 <para>
11 Some of the Glasgow extensions serve to give you access to the
12 underlying facilities with which we implement Haskell.  Thus, you can
13 get at the Raw Iron, if you are willing to write some non-portable
14 code at a more primitive level.  You need not be &ldquo;stuck&rdquo;
15 on performance because of the implementation costs of Haskell's
16 &ldquo;high-level&rdquo; features&mdash;you can always code
17 &ldquo;under&rdquo; them.  In an extreme case, you can write all your
18 time-critical code in C, and then just glue it together with Haskell!
19 </para>
20
21 <para>
22 Before you get too carried away working at the lowest level (e.g.,
23 sloshing <literal>MutableByteArray&num;</literal>s around your
24 program), you may wish to check if there are libraries that provide a
25 &ldquo;Haskellised veneer&rdquo; over the features you want.  The
26 separate <ulink url="../libraries/index.html">libraries
27 documentation</ulink> describes all the libraries that come with GHC.
28 </para>
29
30 <!-- LANGUAGE OPTIONS -->
31   <sect1 id="options-language">
32     <title>Language options</title>
33
34     <indexterm><primary>language</primary><secondary>option</secondary>
35     </indexterm>
36     <indexterm><primary>options</primary><secondary>language</secondary>
37     </indexterm>
38     <indexterm><primary>extensions</primary><secondary>options controlling</secondary>
39     </indexterm>
40
41     <para>The language option flags control what variation of the language are
42     permitted.  Leaving out all of them gives you standard Haskell
43     98.</para>
44
45     <para>Language options can be controlled in two ways:
46     <itemizedlist>
47       <listitem><para>Every language option can switched on by a command-line flag "<option>-X...</option>" 
48         (e.g. <option>-XTemplateHaskell</option>), and switched off by the flag "<option>-XNo...</option>"; 
49         (e.g. <option>-XNoTemplateHaskell</option>).</para></listitem>
50       <listitem><para>
51           Language options recognised by Cabal can also be enabled using the <literal>LANGUAGE</literal> pragma,
52           thus <literal>{-# LANGUAGE TemplateHaskell #-}</literal> (see <xref linkend="language-pragma"/>). </para>
53           </listitem>
54       </itemizedlist></para>
55
56     <para>The flag <option>-fglasgow-exts</option>
57           <indexterm><primary><option>-fglasgow-exts</option></primary></indexterm>
58           is equivalent to enabling the following extensions: 
59           <option>-XPrintExplicitForalls</option>,
60           <option>-XForeignFunctionInterface</option>,
61           <option>-XUnliftedFFITypes</option>,
62           <option>-XGADTs</option>,
63           <option>-XImplicitParams</option>,
64           <option>-XScopedTypeVariables</option>,
65           <option>-XUnboxedTuples</option>,
66           <option>-XTypeSynonymInstances</option>,
67           <option>-XStandaloneDeriving</option>,
68           <option>-XDeriveDataTypeable</option>,
69           <option>-XFlexibleContexts</option>,
70           <option>-XFlexibleInstances</option>,
71           <option>-XConstrainedClassMethods</option>,
72           <option>-XMultiParamTypeClasses</option>,
73           <option>-XFunctionalDependencies</option>,
74           <option>-XMagicHash</option>,
75           <option>-XPolymorphicComponents</option>,
76           <option>-XExistentialQuantification</option>,
77           <option>-XUnicodeSyntax</option>,
78           <option>-XPostfixOperators</option>,
79           <option>-XPatternGuards</option>,
80           <option>-XLiberalTypeSynonyms</option>,
81           <option>-XExplicitForAll</option>,
82           <option>-XRankNTypes</option>,
83           <option>-XImpredicativeTypes</option>,
84           <option>-XTypeOperators</option>,
85           <option>-XDoRec</option>,
86           <option>-XParallelListComp</option>,
87           <option>-XEmptyDataDecls</option>,
88           <option>-XKindSignatures</option>,
89           <option>-XGeneralizedNewtypeDeriving</option>,
90           <option>-XTypeFamilies</option>.
91             Enabling these options is the <emphasis>only</emphasis> 
92             effect of <option>-fglasgow-exts</option>.
93           We are trying to move away from this portmanteau flag, 
94           and towards enabling features individually.</para>
95
96   </sect1>
97
98 <!-- UNBOXED TYPES AND PRIMITIVE OPERATIONS -->
99 <sect1 id="primitives">
100   <title>Unboxed types and primitive operations</title>
101
102 <para>GHC is built on a raft of primitive data types and operations;
103 "primitive" in the sense that they cannot be defined in Haskell itself.
104 While you really can use this stuff to write fast code,
105   we generally find it a lot less painful, and more satisfying in the
106   long run, to use higher-level language features and libraries.  With
107   any luck, the code you write will be optimised to the efficient
108   unboxed version in any case.  And if it isn't, we'd like to know
109   about it.</para>
110
111 <para>All these primitive data types and operations are exported by the 
112 library <literal>GHC.Prim</literal>, for which there is 
113 <ulink url="&libraryGhcPrimLocation;/GHC-Prim.html">detailed online documentation</ulink>.
114 (This documentation is generated from the file <filename>compiler/prelude/primops.txt.pp</filename>.)
115 </para>
116 <para>
117 If you want to mention any of the primitive data types or operations in your
118 program, you must first import <literal>GHC.Prim</literal> to bring them
119 into scope.  Many of them have names ending in "&num;", and to mention such
120 names you need the <option>-XMagicHash</option> extension (<xref linkend="magic-hash"/>).
121 </para>
122
123 <para>The primops make extensive use of <link linkend="glasgow-unboxed">unboxed types</link> 
124 and <link linkend="unboxed-tuples">unboxed tuples</link>, which
125 we briefly summarise here. </para>
126   
127 <sect2 id="glasgow-unboxed">
128 <title>Unboxed types
129 </title>
130
131 <para>
132 <indexterm><primary>Unboxed types (Glasgow extension)</primary></indexterm>
133 </para>
134
135 <para>Most types in GHC are <firstterm>boxed</firstterm>, which means
136 that values of that type are represented by a pointer to a heap
137 object.  The representation of a Haskell <literal>Int</literal>, for
138 example, is a two-word heap object.  An <firstterm>unboxed</firstterm>
139 type, however, is represented by the value itself, no pointers or heap
140 allocation are involved.
141 </para>
142
143 <para>
144 Unboxed types correspond to the &ldquo;raw machine&rdquo; types you
145 would use in C: <literal>Int&num;</literal> (long int),
146 <literal>Double&num;</literal> (double), <literal>Addr&num;</literal>
147 (void *), etc.  The <emphasis>primitive operations</emphasis>
148 (PrimOps) on these types are what you might expect; e.g.,
149 <literal>(+&num;)</literal> is addition on
150 <literal>Int&num;</literal>s, and is the machine-addition that we all
151 know and love&mdash;usually one instruction.
152 </para>
153
154 <para>
155 Primitive (unboxed) types cannot be defined in Haskell, and are
156 therefore built into the language and compiler.  Primitive types are
157 always unlifted; that is, a value of a primitive type cannot be
158 bottom.  We use the convention (but it is only a convention) 
159 that primitive types, values, and
160 operations have a <literal>&num;</literal> suffix (see <xref linkend="magic-hash"/>).
161 For some primitive types we have special syntax for literals, also
162 described in the <link linkend="magic-hash">same section</link>.
163 </para>
164
165 <para>
166 Primitive values are often represented by a simple bit-pattern, such
167 as <literal>Int&num;</literal>, <literal>Float&num;</literal>,
168 <literal>Double&num;</literal>.  But this is not necessarily the case:
169 a primitive value might be represented by a pointer to a
170 heap-allocated object.  Examples include
171 <literal>Array&num;</literal>, the type of primitive arrays.  A
172 primitive array is heap-allocated because it is too big a value to fit
173 in a register, and would be too expensive to copy around; in a sense,
174 it is accidental that it is represented by a pointer.  If a pointer
175 represents a primitive value, then it really does point to that value:
176 no unevaluated thunks, no indirections&hellip;nothing can be at the
177 other end of the pointer than the primitive value.
178 A numerically-intensive program using unboxed types can
179 go a <emphasis>lot</emphasis> faster than its &ldquo;standard&rdquo;
180 counterpart&mdash;we saw a threefold speedup on one example.
181 </para>
182
183 <para>
184 There are some restrictions on the use of primitive types:
185 <itemizedlist>
186 <listitem><para>The main restriction
187 is that you can't pass a primitive value to a polymorphic
188 function or store one in a polymorphic data type.  This rules out
189 things like <literal>[Int&num;]</literal> (i.e. lists of primitive
190 integers).  The reason for this restriction is that polymorphic
191 arguments and constructor fields are assumed to be pointers: if an
192 unboxed integer is stored in one of these, the garbage collector would
193 attempt to follow it, leading to unpredictable space leaks.  Or a
194 <function>seq</function> operation on the polymorphic component may
195 attempt to dereference the pointer, with disastrous results.  Even
196 worse, the unboxed value might be larger than a pointer
197 (<literal>Double&num;</literal> for instance).
198 </para>
199 </listitem>
200 <listitem><para> You cannot define a newtype whose representation type
201 (the argument type of the data constructor) is an unboxed type.  Thus,
202 this is illegal:
203 <programlisting>
204   newtype A = MkA Int#
205 </programlisting>
206 </para></listitem>
207 <listitem><para> You cannot bind a variable with an unboxed type
208 in a <emphasis>top-level</emphasis> binding.
209 </para></listitem>
210 <listitem><para> You cannot bind a variable with an unboxed type
211 in a <emphasis>recursive</emphasis> binding.
212 </para></listitem>
213 <listitem><para> You may bind unboxed variables in a (non-recursive,
214 non-top-level) pattern binding, but you must make any such pattern-match
215 strict.  For example, rather than:
216 <programlisting>
217   data Foo = Foo Int Int#
218
219   f x = let (Foo a b, w) = ..rhs.. in ..body..
220 </programlisting>
221 you must write:
222 <programlisting>
223   data Foo = Foo Int Int#
224
225   f x = let !(Foo a b, w) = ..rhs.. in ..body..
226 </programlisting>
227 since <literal>b</literal> has type <literal>Int#</literal>.
228 </para>
229 </listitem>
230 </itemizedlist>
231 </para>
232
233 </sect2>
234
235 <sect2 id="unboxed-tuples">
236 <title>Unboxed Tuples
237 </title>
238
239 <para>
240 Unboxed tuples aren't really exported by <literal>GHC.Exts</literal>,
241 they're available by default with <option>-fglasgow-exts</option>.  An
242 unboxed tuple looks like this:
243 </para>
244
245 <para>
246
247 <programlisting>
248 (# e_1, ..., e_n #)
249 </programlisting>
250
251 </para>
252
253 <para>
254 where <literal>e&lowbar;1..e&lowbar;n</literal> are expressions of any
255 type (primitive or non-primitive).  The type of an unboxed tuple looks
256 the same.
257 </para>
258
259 <para>
260 Unboxed tuples are used for functions that need to return multiple
261 values, but they avoid the heap allocation normally associated with
262 using fully-fledged tuples.  When an unboxed tuple is returned, the
263 components are put directly into registers or on the stack; the
264 unboxed tuple itself does not have a composite representation.  Many
265 of the primitive operations listed in <literal>primops.txt.pp</literal> return unboxed
266 tuples.
267 In particular, the <literal>IO</literal> and <literal>ST</literal> monads use unboxed
268 tuples to avoid unnecessary allocation during sequences of operations.
269 </para>
270
271 <para>
272 There are some pretty stringent restrictions on the use of unboxed tuples:
273 <itemizedlist>
274 <listitem>
275
276 <para>
277 Values of unboxed tuple types are subject to the same restrictions as
278 other unboxed types; i.e. they may not be stored in polymorphic data
279 structures or passed to polymorphic functions.
280
281 </para>
282 </listitem>
283 <listitem>
284
285 <para>
286 No variable can have an unboxed tuple type, nor may a constructor or function
287 argument have an unboxed tuple type.  The following are all illegal:
288
289
290 <programlisting>
291   data Foo = Foo (# Int, Int #)
292
293   f :: (# Int, Int #) -&#62; (# Int, Int #)
294   f x = x
295
296   g :: (# Int, Int #) -&#62; Int
297   g (# a,b #) = a
298
299   h x = let y = (# x,x #) in ...
300 </programlisting>
301 </para>
302 </listitem>
303 </itemizedlist>
304 </para>
305 <para>
306 The typical use of unboxed tuples is simply to return multiple values,
307 binding those multiple results with a <literal>case</literal> expression, thus:
308 <programlisting>
309   f x y = (# x+1, y-1 #)
310   g x = case f x x of { (# a, b #) -&#62; a + b }
311 </programlisting>
312 You can have an unboxed tuple in a pattern binding, thus
313 <programlisting>
314   f x = let (# p,q #) = h x in ..body..
315 </programlisting>
316 If the types of <literal>p</literal> and <literal>q</literal> are not unboxed,
317 the resulting binding is lazy like any other Haskell pattern binding.  The 
318 above example desugars like this:
319 <programlisting>
320   f x = let t = case h x o f{ (# p,q #) -> (p,q)
321             p = fst t
322             q = snd t
323         in ..body..
324 </programlisting>
325 Indeed, the bindings can even be recursive.
326 </para>
327
328 </sect2>
329 </sect1>
330
331
332 <!-- ====================== SYNTACTIC EXTENSIONS =======================  -->
333
334 <sect1 id="syntax-extns">
335 <title>Syntactic extensions</title>
336  
337     <sect2 id="unicode-syntax">
338       <title>Unicode syntax</title>
339       <para>The language
340       extension <option>-XUnicodeSyntax</option><indexterm><primary><option>-XUnicodeSyntax</option></primary></indexterm>
341       enables Unicode characters to be used to stand for certain ASCII
342       character sequences.  The following alternatives are provided:</para>
343
344       <informaltable>
345         <tgroup cols="2" align="left" colsep="1" rowsep="1">
346           <thead>
347             <row>
348               <entry>ASCII</entry>
349               <entry>Unicode alternative</entry>
350               <entry>Code point</entry>
351               <entry>Name</entry>
352             </row>
353           </thead>
354
355 <!--
356                to find the DocBook entities for these characters, find
357                the Unicode code point (e.g. 0x2237), and grep for it in
358                /usr/share/sgml/docbook/xml-dtd-*/ent/* (or equivalent on
359                your system.  Some of these Unicode code points don't have
360                equivalent DocBook entities.
361             -->
362
363           <tbody>
364             <row>
365               <entry><literal>::</literal></entry>
366               <entry>::</entry> <!-- no special char, apparently -->
367               <entry>0x2237</entry>
368               <entry>PROPORTION</entry>
369             </row>
370           </tbody>
371           <tbody>
372             <row>
373               <entry><literal>=&gt;</literal></entry>
374               <entry>&rArr;</entry>
375               <entry>0x21D2</entry>
376               <entry>RIGHTWARDS DOUBLE ARROW</entry>
377             </row>
378           </tbody>
379           <tbody>
380             <row>
381               <entry><literal>forall</literal></entry>
382               <entry>&forall;</entry>
383               <entry>0x2200</entry>
384               <entry>FOR ALL</entry>
385             </row>
386           </tbody>
387           <tbody>
388             <row>
389               <entry><literal>-&gt;</literal></entry>
390               <entry>&rarr;</entry>
391               <entry>0x2192</entry>
392               <entry>RIGHTWARDS ARROW</entry>
393             </row>
394           </tbody>
395           <tbody>
396             <row>
397               <entry><literal>&lt;-</literal></entry>
398               <entry>&larr;</entry>
399               <entry>0x2190</entry>
400               <entry>LEFTWARDS ARROW</entry>
401             </row>
402           </tbody>
403           <tbody>
404             <row>
405               <entry>..</entry>
406               <entry>&hellip;</entry>
407               <entry>0x22EF</entry>
408               <entry>MIDLINE HORIZONTAL ELLIPSIS</entry>
409             </row>
410           </tbody>
411
412           <tbody>
413             <row>
414               <entry>-&lt;</entry>
415               <entry>&larrtl;</entry>
416               <entry>0x2919</entry>
417               <entry>LEFTWARDS ARROW-TAIL</entry>
418             </row>
419           </tbody>
420
421           <tbody>
422             <row>
423               <entry>&gt;-</entry>
424               <entry>&rarrtl;</entry>
425               <entry>0x291A</entry>
426               <entry>RIGHTWARDS ARROW-TAIL</entry>
427             </row>
428           </tbody>
429
430           <tbody>
431             <row>
432               <entry>-&lt;&lt;</entry>
433               <entry></entry>
434               <entry>0x291B</entry>
435               <entry>LEFTWARDS DOUBLE ARROW-TAIL</entry>
436             </row>
437           </tbody>
438
439           <tbody>
440             <row>
441               <entry>&gt;&gt;-</entry>
442               <entry></entry>
443               <entry>0x291C</entry>
444               <entry>RIGHTWARDS DOUBLE ARROW-TAIL</entry>
445             </row>
446           </tbody>
447
448           <tbody>
449             <row>
450               <entry>*</entry>
451               <entry>&starf;</entry>
452               <entry>0x2605</entry>
453               <entry>BLACK STAR</entry>
454             </row>
455           </tbody>
456
457         </tgroup>
458       </informaltable>
459     </sect2>
460
461     <sect2 id="magic-hash">
462       <title>The magic hash</title>
463       <para>The language extension <option>-XMagicHash</option> allows "&num;" as a
464         postfix modifier to identifiers.  Thus, "x&num;" is a valid variable, and "T&num;" is
465         a valid type constructor or data constructor.</para>
466
467       <para>The hash sign does not change sematics at all.  We tend to use variable
468         names ending in "&num;" for unboxed values or types (e.g. <literal>Int&num;</literal>), 
469         but there is no requirement to do so; they are just plain ordinary variables.
470         Nor does the <option>-XMagicHash</option> extension bring anything into scope.
471         For example, to bring <literal>Int&num;</literal> into scope you must 
472         import <literal>GHC.Prim</literal> (see <xref linkend="primitives"/>); 
473         the <option>-XMagicHash</option> extension
474         then allows you to <emphasis>refer</emphasis> to the <literal>Int&num;</literal>
475         that is now in scope.</para>
476       <para> The <option>-XMagicHash</option> also enables some new forms of literals (see <xref linkend="glasgow-unboxed"/>):
477         <itemizedlist> 
478           <listitem><para> <literal>'x'&num;</literal> has type <literal>Char&num;</literal></para> </listitem>
479           <listitem><para> <literal>&quot;foo&quot;&num;</literal> has type <literal>Addr&num;</literal></para> </listitem>
480           <listitem><para> <literal>3&num;</literal> has type <literal>Int&num;</literal>. In general,
481           any Haskell 98 integer lexeme followed by a <literal>&num;</literal> is an <literal>Int&num;</literal> literal, e.g.
482             <literal>-0x3A&num;</literal> as well as <literal>32&num;</literal></para>.</listitem>
483           <listitem><para> <literal>3&num;&num;</literal> has type <literal>Word&num;</literal>. In general,
484           any non-negative Haskell 98 integer lexeme followed by <literal>&num;&num;</literal> 
485               is a <literal>Word&num;</literal>. </para> </listitem>
486           <listitem><para> <literal>3.2&num;</literal> has type <literal>Float&num;</literal>.</para> </listitem>
487           <listitem><para> <literal>3.2&num;&num;</literal> has type <literal>Double&num;</literal></para> </listitem>
488           </itemizedlist>
489       </para>
490    </sect2>
491
492     <sect2 id="new-qualified-operators">
493       <title>New qualified operator syntax</title>
494
495       <para>A new syntax for referencing qualified operators is
496         planned to be introduced by Haskell', and is enabled in GHC
497         with
498         the <option>-XNewQualifiedOperators</option><indexterm><primary><option>-XNewQualifiedOperators</option></primary></indexterm>
499         option.  In the new syntax, the prefix form of a qualified
500         operator is
501         written <literal><replaceable>module</replaceable>.(<replaceable>symbol</replaceable>)</literal>
502         (in Haskell 98 this would
503         be <literal>(<replaceable>module</replaceable>.<replaceable>symbol</replaceable>)</literal>),
504         and the infix form is
505         written <literal>`<replaceable>module</replaceable>.(<replaceable>symbol</replaceable>)`</literal>
506         (in Haskell 98 this would
507         be <literal>`<replaceable>module</replaceable>.<replaceable>symbol</replaceable>`</literal>.
508         For example:
509 <programlisting>
510   add x y = Prelude.(+) x y
511   subtract y = (`Prelude.(-)` y)
512 </programlisting>
513         The new form of qualified operators is intended to regularise
514         the syntax by eliminating odd cases
515         like <literal>Prelude..</literal>.  For example,
516         when <literal>NewQualifiedOperators</literal> is on, it is possible to
517         write the enumerated sequence <literal>[Monday..]</literal>
518         without spaces, whereas in Haskell 98 this would be a
519         reference to the operator &lsquo;<literal>.</literal>&lsquo;
520         from module <literal>Monday</literal>.</para>
521
522       <para>When <option>-XNewQualifiedOperators</option> is on, the old Haskell
523         98 syntax for qualified operators is not accepted, so this
524         option may cause existing Haskell 98 code to break.</para>
525
526     </sect2>
527         
528
529     <!-- ====================== HIERARCHICAL MODULES =======================  -->
530
531
532     <sect2 id="hierarchical-modules">
533       <title>Hierarchical Modules</title>
534
535       <para>GHC supports a small extension to the syntax of module
536       names: a module name is allowed to contain a dot
537       <literal>&lsquo;.&rsquo;</literal>.  This is also known as the
538       &ldquo;hierarchical module namespace&rdquo; extension, because
539       it extends the normally flat Haskell module namespace into a
540       more flexible hierarchy of modules.</para>
541
542       <para>This extension has very little impact on the language
543       itself; modules names are <emphasis>always</emphasis> fully
544       qualified, so you can just think of the fully qualified module
545       name as <quote>the module name</quote>.  In particular, this
546       means that the full module name must be given after the
547       <literal>module</literal> keyword at the beginning of the
548       module; for example, the module <literal>A.B.C</literal> must
549       begin</para>
550
551 <programlisting>module A.B.C</programlisting>
552
553
554       <para>It is a common strategy to use the <literal>as</literal>
555       keyword to save some typing when using qualified names with
556       hierarchical modules.  For example:</para>
557
558 <programlisting>
559 import qualified Control.Monad.ST.Strict as ST
560 </programlisting>
561
562       <para>For details on how GHC searches for source and interface
563       files in the presence of hierarchical modules, see <xref
564       linkend="search-path"/>.</para>
565
566       <para>GHC comes with a large collection of libraries arranged
567       hierarchically; see the accompanying <ulink
568       url="../libraries/index.html">library
569       documentation</ulink>.  More libraries to install are available
570       from <ulink
571       url="http://hackage.haskell.org/packages/hackage.html">HackageDB</ulink>.</para>
572     </sect2>
573
574     <!-- ====================== PATTERN GUARDS =======================  -->
575
576 <sect2 id="pattern-guards">
577 <title>Pattern guards</title>
578
579 <para>
580 <indexterm><primary>Pattern guards (Glasgow extension)</primary></indexterm>
581 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.)
582 </para>
583
584 <para>
585 Suppose we have an abstract data type of finite maps, with a
586 lookup operation:
587
588 <programlisting>
589 lookup :: FiniteMap -> Int -> Maybe Int
590 </programlisting>
591
592 The lookup returns <function>Nothing</function> if the supplied key is not in the domain of the mapping, and <function>(Just v)</function> otherwise,
593 where <varname>v</varname> is the value that the key maps to.  Now consider the following definition:
594 </para>
595
596 <programlisting>
597 clunky env var1 var2 | ok1 &amp;&amp; ok2 = val1 + val2
598 | otherwise  = var1 + var2
599 where
600   m1 = lookup env var1
601   m2 = lookup env var2
602   ok1 = maybeToBool m1
603   ok2 = maybeToBool m2
604   val1 = expectJust m1
605   val2 = expectJust m2
606 </programlisting>
607
608 <para>
609 The auxiliary functions are 
610 </para>
611
612 <programlisting>
613 maybeToBool :: Maybe a -&gt; Bool
614 maybeToBool (Just x) = True
615 maybeToBool Nothing  = False
616
617 expectJust :: Maybe a -&gt; a
618 expectJust (Just x) = x
619 expectJust Nothing  = error "Unexpected Nothing"
620 </programlisting>
621
622 <para>
623 What is <function>clunky</function> doing? The guard <literal>ok1 &amp;&amp;
624 ok2</literal> checks that both lookups succeed, using
625 <function>maybeToBool</function> to convert the <function>Maybe</function>
626 types to booleans. The (lazily evaluated) <function>expectJust</function>
627 calls extract the values from the results of the lookups, and binds the
628 returned values to <varname>val1</varname> and <varname>val2</varname>
629 respectively.  If either lookup fails, then clunky takes the
630 <literal>otherwise</literal> case and returns the sum of its arguments.
631 </para>
632
633 <para>
634 This is certainly legal Haskell, but it is a tremendously verbose and
635 un-obvious way to achieve the desired effect.  Arguably, a more direct way
636 to write clunky would be to use case expressions:
637 </para>
638
639 <programlisting>
640 clunky env var1 var2 = case lookup env var1 of
641   Nothing -&gt; fail
642   Just val1 -&gt; case lookup env var2 of
643     Nothing -&gt; fail
644     Just val2 -&gt; val1 + val2
645 where
646   fail = var1 + var2
647 </programlisting>
648
649 <para>
650 This is a bit shorter, but hardly better.  Of course, we can rewrite any set
651 of pattern-matching, guarded equations as case expressions; that is
652 precisely what the compiler does when compiling equations! The reason that
653 Haskell provides guarded equations is because they allow us to write down
654 the cases we want to consider, one at a time, independently of each other. 
655 This structure is hidden in the case version.  Two of the right-hand sides
656 are really the same (<function>fail</function>), and the whole expression
657 tends to become more and more indented. 
658 </para>
659
660 <para>
661 Here is how I would write clunky:
662 </para>
663
664 <programlisting>
665 clunky env var1 var2
666   | Just val1 &lt;- lookup env var1
667   , Just val2 &lt;- lookup env var2
668   = val1 + val2
669 ...other equations for clunky...
670 </programlisting>
671
672 <para>
673 The semantics should be clear enough.  The qualifiers are matched in order. 
674 For a <literal>&lt;-</literal> qualifier, which I call a pattern guard, the
675 right hand side is evaluated and matched against the pattern on the left. 
676 If the match fails then the whole guard fails and the next equation is
677 tried.  If it succeeds, then the appropriate binding takes place, and the
678 next qualifier is matched, in the augmented environment.  Unlike list
679 comprehensions, however, the type of the expression to the right of the
680 <literal>&lt;-</literal> is the same as the type of the pattern to its
681 left.  The bindings introduced by pattern guards scope over all the
682 remaining guard qualifiers, and over the right hand side of the equation.
683 </para>
684
685 <para>
686 Just as with list comprehensions, boolean expressions can be freely mixed
687 with among the pattern guards.  For example:
688 </para>
689
690 <programlisting>
691 f x | [y] &lt;- x
692     , y > 3
693     , Just z &lt;- h y
694     = ...
695 </programlisting>
696
697 <para>
698 Haskell's current guards therefore emerge as a special case, in which the
699 qualifier list has just one element, a boolean expression.
700 </para>
701 </sect2>
702
703     <!-- ===================== View patterns ===================  -->
704
705 <sect2 id="view-patterns">
706 <title>View patterns
707 </title>
708
709 <para>
710 View patterns are enabled by the flag <literal>-XViewPatterns</literal>.
711 More information and examples of view patterns can be found on the
712 <ulink url="http://hackage.haskell.org/trac/ghc/wiki/ViewPatterns">Wiki
713 page</ulink>.
714 </para>
715
716 <para>
717 View patterns are somewhat like pattern guards that can be nested inside
718 of other patterns.  They are a convenient way of pattern-matching
719 against values of abstract types. For example, in a programming language
720 implementation, we might represent the syntax of the types of the
721 language as follows:
722
723 <programlisting>
724 type Typ
725  
726 data TypView = Unit
727              | Arrow Typ Typ
728
729 view :: Type -> TypeView
730
731 -- additional operations for constructing Typ's ...
732 </programlisting>
733
734 The representation of Typ is held abstract, permitting implementations
735 to use a fancy representation (e.g., hash-consing to manage sharing).
736
737 Without view patterns, using this signature a little inconvenient: 
738 <programlisting>
739 size :: Typ -> Integer
740 size t = case view t of
741   Unit -> 1
742   Arrow t1 t2 -> size t1 + size t2
743 </programlisting>
744
745 It is necessary to iterate the case, rather than using an equational
746 function definition. And the situation is even worse when the matching
747 against <literal>t</literal> is buried deep inside another pattern.
748 </para>
749
750 <para>
751 View patterns permit calling the view function inside the pattern and
752 matching against the result: 
753 <programlisting>
754 size (view -> Unit) = 1
755 size (view -> Arrow t1 t2) = size t1 + size t2
756 </programlisting>
757
758 That is, we add a new form of pattern, written
759 <replaceable>expression</replaceable> <literal>-></literal>
760 <replaceable>pattern</replaceable> that means "apply the expression to
761 whatever we're trying to match against, and then match the result of
762 that application against the pattern". The expression can be any Haskell
763 expression of function type, and view patterns can be used wherever
764 patterns are used.
765 </para>
766
767 <para>
768 The semantics of a pattern <literal>(</literal>
769 <replaceable>exp</replaceable> <literal>-></literal>
770 <replaceable>pat</replaceable> <literal>)</literal> are as follows:
771
772 <itemizedlist>
773
774 <listitem> Scoping:
775
776 <para>The variables bound by the view pattern are the variables bound by
777 <replaceable>pat</replaceable>.
778 </para>
779
780 <para>
781 Any variables in <replaceable>exp</replaceable> are bound occurrences,
782 but variables bound "to the left" in a pattern are in scope.  This
783 feature permits, for example, one argument to a function to be used in
784 the view of another argument.  For example, the function
785 <literal>clunky</literal> from <xref linkend="pattern-guards" /> can be
786 written using view patterns as follows:
787
788 <programlisting>
789 clunky env (lookup env -> Just val1) (lookup env -> Just val2) = val1 + val2
790 ...other equations for clunky...
791 </programlisting>
792 </para>
793
794 <para>
795 More precisely, the scoping rules are: 
796 <itemizedlist>
797 <listitem>
798 <para>
799 In a single pattern, variables bound by patterns to the left of a view
800 pattern expression are in scope. For example:
801 <programlisting>
802 example :: Maybe ((String -> Integer,Integer), String) -> Bool
803 example Just ((f,_), f -> 4) = True
804 </programlisting>
805
806 Additionally, in function definitions, variables bound by matching earlier curried
807 arguments may be used in view pattern expressions in later arguments:
808 <programlisting>
809 example :: (String -> Integer) -> String -> Bool
810 example f (f -> 4) = True
811 </programlisting>
812 That is, the scoping is the same as it would be if the curried arguments
813 were collected into a tuple.  
814 </para>
815 </listitem>
816
817 <listitem>
818 <para>
819 In mutually recursive bindings, such as <literal>let</literal>,
820 <literal>where</literal>, or the top level, view patterns in one
821 declaration may not mention variables bound by other declarations.  That
822 is, each declaration must be self-contained.  For example, the following
823 program is not allowed:
824 <programlisting>
825 let {(x -> y) = e1 ;
826      (y -> x) = e2 } in x
827 </programlisting>
828
829 (We may lift this
830 restriction in the future; the only cost is that type checking patterns
831 would get a little more complicated.)  
832
833
834 </para>
835 </listitem>
836 </itemizedlist>
837
838 </para>
839 </listitem>
840
841 <listitem><para> Typing: If <replaceable>exp</replaceable> has type
842 <replaceable>T1</replaceable> <literal>-></literal>
843 <replaceable>T2</replaceable> and <replaceable>pat</replaceable> matches
844 a <replaceable>T2</replaceable>, then the whole view pattern matches a
845 <replaceable>T1</replaceable>.
846 </para></listitem>
847
848 <listitem><para> Matching: To the equations in Section 3.17.3 of the
849 <ulink url="http://www.haskell.org/onlinereport/">Haskell 98
850 Report</ulink>, add the following:
851 <programlisting>
852 case v of { (e -> p) -> e1 ; _ -> e2 } 
853  = 
854 case (e v) of { p -> e1 ; _ -> e2 }
855 </programlisting>
856 That is, to match a variable <replaceable>v</replaceable> against a pattern
857 <literal>(</literal> <replaceable>exp</replaceable>
858 <literal>-></literal> <replaceable>pat</replaceable>
859 <literal>)</literal>, evaluate <literal>(</literal>
860 <replaceable>exp</replaceable> <replaceable> v</replaceable>
861 <literal>)</literal> and match the result against
862 <replaceable>pat</replaceable>.  
863 </para></listitem>
864
865 <listitem><para> Efficiency: When the same view function is applied in
866 multiple branches of a function definition or a case expression (e.g.,
867 in <literal>size</literal> above), GHC makes an attempt to collect these
868 applications into a single nested case expression, so that the view
869 function is only applied once.  Pattern compilation in GHC follows the
870 matrix algorithm described in Chapter 4 of <ulink
871 url="http://research.microsoft.com/~simonpj/Papers/slpj-book-1987/">The
872 Implementation of Functional Programming Languages</ulink>.  When the
873 top rows of the first column of a matrix are all view patterns with the
874 "same" expression, these patterns are transformed into a single nested
875 case.  This includes, for example, adjacent view patterns that line up
876 in a tuple, as in
877 <programlisting>
878 f ((view -> A, p1), p2) = e1
879 f ((view -> B, p3), p4) = e2
880 </programlisting>
881 </para>
882
883 <para> The current notion of when two view pattern expressions are "the
884 same" is very restricted: it is not even full syntactic equality.
885 However, it does include variables, literals, applications, and tuples;
886 e.g., two instances of <literal>view ("hi", "there")</literal> will be
887 collected.  However, the current implementation does not compare up to
888 alpha-equivalence, so two instances of <literal>(x, view x ->
889 y)</literal> will not be coalesced.
890 </para>
891
892 </listitem>
893
894 </itemizedlist>
895 </para>
896
897 </sect2>
898
899     <!-- ===================== n+k patterns ===================  -->
900
901 <sect2 id="n-k-patterns">
902 <title>n+k patterns</title>
903 <indexterm><primary><option>-XNoNPlusKPatterns</option></primary></indexterm>
904
905 <para>
906 <literal>n+k</literal> pattern support is enabled by default. To disable
907 it, you can use the <option>-XNoNPlusKPatterns</option> flag.
908 </para>
909
910 </sect2>
911
912     <!-- ===================== Recursive do-notation ===================  -->
913
914 <sect2 id="recursive-do-notation">
915 <title>The recursive do-notation
916 </title>
917
918 <para>
919 The do-notation of Haskell 98 does not allow <emphasis>recursive bindings</emphasis>,
920 that is, the variables bound in a do-expression are visible only in the textually following 
921 code block. Compare this to a let-expression, where bound variables are visible in the entire binding
922 group. It turns out that several applications can benefit from recursive bindings in
923 the do-notation.  The <option>-XDoRec</option> flag provides the necessary syntactic support.
924 </para>
925 <para>
926 Here is a simple (albeit contrived) example:
927 <programlisting>
928 {-# LANGUAGE DoRec #-}
929 justOnes = do { rec { xs &lt;- Just (1:xs) }
930               ; return (map negate xs) }
931 </programlisting>
932 As you can guess <literal>justOnes</literal> will evaluate to <literal>Just [-1,-1,-1,...</literal>.
933 </para>
934 <para>
935 The background and motivation for recursive do-notation is described in
936 <ulink url="http://sites.google.com/site/leventerkok/">A recursive do for Haskell</ulink>,
937 by Levent Erkok, John Launchbury,
938 Haskell Workshop 2002, pages: 29-37. Pittsburgh, Pennsylvania. 
939 The theory behind monadic value recursion is explained further in Erkok's thesis
940 <ulink url="http://sites.google.com/site/leventerkok/erkok-thesis.pdf">Value Recursion in Monadic Computations</ulink>.
941 However, note that GHC uses a different syntax than the one described in these documents.
942 </para>
943
944 <sect3>
945 <title>Details of recursive do-notation</title>
946 <para>
947 The recursive do-notation is enabled with the flag <option>-XDoRec</option> or, equivalently,
948 the LANGUAGE pragma <option>DoRec</option>.  It introduces the single new keyword "<literal>rec</literal>",
949 which wraps a mutually-recursive group of monadic statements,
950 producing a single statement.
951 </para>
952 <para>Similar to a <literal>let</literal>
953 statement, the variables bound in the <literal>rec</literal> are 
954 visible throughout the <literal>rec</literal> group, and below it.
955 For example, compare
956 <programlisting>
957 do { a &lt;- getChar              do { a &lt;- getChar                    
958    ; let { r1 = f a r2             ; rec { r1 &lt;- f a r2      
959          ; r2 = g r1 }                   ; r2 &lt;- g r1 }      
960    ; return (r1 ++ r2) }          ; return (r1 ++ r2) }
961 </programlisting>
962 In both cases, <literal>r1</literal> and <literal>r2</literal> are 
963 available both throughout the <literal>let</literal> or <literal>rec</literal> block, and
964 in the statements that follow it.  The difference is that <literal>let</literal> is non-monadic,
965 while <literal>rec</literal> is monadic.  (In Haskell <literal>let</literal> is 
966 really <literal>letrec</literal>, of course.)
967 </para>
968 <para>
969 The static and dynamic semantics of <literal>rec</literal> can be described as follows:  
970 <itemizedlist>
971 <listitem><para>
972 First,
973 similar to let-bindings, the <literal>rec</literal> is broken into 
974 minimal recursive groups, a process known as <emphasis>segmentation</emphasis>.
975 For example:
976 <programlisting>
977 rec { a &lt;- getChar      ===>     a &lt;- getChar
978     ; b &lt;- f a c                 rec { b &lt;- f a c
979     ; c &lt;- f b a                     ; c &lt;- f b a }
980     ; putChar c }                putChar c 
981 </programlisting>
982 The details of segmentation are described in Section 3.2 of
983 <ulink url="http://sites.google.com/site/leventerkok/">A recursive do for Haskell</ulink>.
984 Segmentation improves polymorphism, reduces the size of the recursive "knot", and, as the paper 
985 describes, also has a semantic effect (unless the monad satisfies the right-shrinking law).
986 </para></listitem>
987 <listitem><para>
988 Then each resulting <literal>rec</literal> is desugared, using a call to <literal>Control.Monad.Fix.mfix</literal>.
989 For example, the <literal>rec</literal> group in the preceding example is desugared like this:
990 <programlisting>
991 rec { b &lt;- f a c     ===>    (b,c) &lt;- mfix (\~(b,c) -> do { b &lt;- f a c
992     ; c &lt;- f b a }                                        ; c &lt;- f b a
993                                                           ; return (b,c) })
994 </programlisting>
995 In general, the statment <literal>rec <replaceable>ss</replaceable></literal>
996 is desugared to the statement
997 <programlisting>
998 <replaceable>vs</replaceable> &lt;- mfix (\~<replaceable>vs</replaceable> -&gt; do { <replaceable>ss</replaceable>; return <replaceable>vs</replaceable> })
999 </programlisting>
1000 where <replaceable>vs</replaceable> is a tuple of the variables bound by <replaceable>ss</replaceable>.
1001 </para><para>
1002 The original <literal>rec</literal> typechecks exactly 
1003 when the above desugared version would do so.  For example, this means that 
1004 the variables <replaceable>vs</replaceable> are all monomorphic in the statements
1005 following the <literal>rec</literal>, because they are bound by a lambda.
1006 </para>
1007 <para>
1008 The <literal>mfix</literal> function is defined in the <literal>MonadFix</literal> 
1009 class, in <literal>Control.Monad.Fix</literal>, thus:
1010 <programlisting>
1011 class Monad m => MonadFix m where
1012    mfix :: (a -> m a) -> m a
1013 </programlisting>
1014 </para>
1015 </listitem>
1016 </itemizedlist>
1017 </para>
1018 <para>
1019 Here are some other important points in using the recursive-do notation:
1020 <itemizedlist>
1021 <listitem><para>
1022 It is enabled with the flag <literal>-XDoRec</literal>, which is in turn implied by
1023 <literal>-fglasgow-exts</literal>.
1024 </para></listitem>
1025
1026 <listitem><para>
1027 If recursive bindings are required for a monad,
1028 then that monad must be declared an instance of the <literal>MonadFix</literal> class.
1029 </para></listitem>
1030
1031 <listitem><para>
1032 The following instances of <literal>MonadFix</literal> are automatically provided: List, Maybe, IO. 
1033 Furthermore, the Control.Monad.ST and Control.Monad.ST.Lazy modules provide the instances of the MonadFix class 
1034 for Haskell's internal state monad (strict and lazy, respectively).
1035 </para></listitem>
1036
1037 <listitem><para>
1038 Like <literal>let</literal> and <literal>where</literal> bindings,
1039 name shadowing is not allowed within a <literal>rec</literal>; 
1040 that is, all the names bound in a single <literal>rec</literal> must
1041 be distinct (Section 3.3 of the paper).
1042 </para></listitem>
1043 <listitem><para>
1044 It supports rebindable syntax (see <xref linkend="rebindable-syntax"/>).
1045 </para></listitem>
1046 </itemizedlist>
1047 </para>
1048 </sect3>
1049
1050 <sect3 id="mdo-notation"> <title> Mdo-notation (deprecated) </title>
1051
1052 <para> GHC used to support the flag <option>-XRecursiveDo</option>,
1053 which enabled the keyword <literal>mdo</literal>, precisely as described in
1054 <ulink url="http://sites.google.com/site/leventerkok/">A recursive do for Haskell</ulink>,
1055 but this is now deprecated.  Instead of <literal>mdo { Q; e }</literal>, write
1056 <literal>do { rec Q; e }</literal>.
1057 </para>
1058 <para>
1059 Historical note: The old implementation of the mdo-notation (and most
1060 of the existing documents) used the name
1061 <literal>MonadRec</literal> for the class and the corresponding library.
1062 This name is not supported by GHC.
1063 </para>
1064 </sect3>
1065
1066 </sect2>
1067
1068
1069    <!-- ===================== PARALLEL LIST COMPREHENSIONS ===================  -->
1070
1071   <sect2 id="parallel-list-comprehensions">
1072     <title>Parallel List Comprehensions</title>
1073     <indexterm><primary>list comprehensions</primary><secondary>parallel</secondary>
1074     </indexterm>
1075     <indexterm><primary>parallel list comprehensions</primary>
1076     </indexterm>
1077
1078     <para>Parallel list comprehensions are a natural extension to list
1079     comprehensions.  List comprehensions can be thought of as a nice
1080     syntax for writing maps and filters.  Parallel comprehensions
1081     extend this to include the zipWith family.</para>
1082
1083     <para>A parallel list comprehension has multiple independent
1084     branches of qualifier lists, each separated by a `|' symbol.  For
1085     example, the following zips together two lists:</para>
1086
1087 <programlisting>
1088    [ (x, y) | x &lt;- xs | y &lt;- ys ] 
1089 </programlisting>
1090
1091     <para>The behavior of parallel list comprehensions follows that of
1092     zip, in that the resulting list will have the same length as the
1093     shortest branch.</para>
1094
1095     <para>We can define parallel list comprehensions by translation to
1096     regular comprehensions.  Here's the basic idea:</para>
1097
1098     <para>Given a parallel comprehension of the form: </para>
1099
1100 <programlisting>
1101    [ e | p1 &lt;- e11, p2 &lt;- e12, ... 
1102        | q1 &lt;- e21, q2 &lt;- e22, ... 
1103        ... 
1104    ] 
1105 </programlisting>
1106
1107     <para>This will be translated to: </para>
1108
1109 <programlisting>
1110    [ e | ((p1,p2), (q1,q2), ...) &lt;- zipN [(p1,p2) | p1 &lt;- e11, p2 &lt;- e12, ...] 
1111                                          [(q1,q2) | q1 &lt;- e21, q2 &lt;- e22, ...] 
1112                                          ... 
1113    ] 
1114 </programlisting>
1115
1116     <para>where `zipN' is the appropriate zip for the given number of
1117     branches.</para>
1118
1119   </sect2>
1120   
1121   <!-- ===================== TRANSFORM LIST COMPREHENSIONS ===================  -->
1122
1123   <sect2 id="generalised-list-comprehensions">
1124     <title>Generalised (SQL-Like) List Comprehensions</title>
1125     <indexterm><primary>list comprehensions</primary><secondary>generalised</secondary>
1126     </indexterm>
1127     <indexterm><primary>extended list comprehensions</primary>
1128     </indexterm>
1129     <indexterm><primary>group</primary></indexterm>
1130     <indexterm><primary>sql</primary></indexterm>
1131
1132
1133     <para>Generalised list comprehensions are a further enhancement to the
1134     list comprehension syntactic sugar to allow operations such as sorting
1135     and grouping which are familiar from SQL.   They are fully described in the
1136         paper <ulink url="http://research.microsoft.com/~simonpj/papers/list-comp">
1137           Comprehensive comprehensions: comprehensions with "order by" and "group by"</ulink>,
1138     except that the syntax we use differs slightly from the paper.</para>
1139 <para>The extension is enabled with the flag <option>-XTransformListComp</option>.</para>
1140 <para>Here is an example: 
1141 <programlisting>
1142 employees = [ ("Simon", "MS", 80)
1143 , ("Erik", "MS", 100)
1144 , ("Phil", "Ed", 40)
1145 , ("Gordon", "Ed", 45)
1146 , ("Paul", "Yale", 60)]
1147
1148 output = [ (the dept, sum salary)
1149 | (name, dept, salary) &lt;- employees
1150 , then group by dept
1151 , then sortWith by (sum salary)
1152 , then take 5 ]
1153 </programlisting>
1154 In this example, the list <literal>output</literal> would take on 
1155     the value:
1156     
1157 <programlisting>
1158 [("Yale", 60), ("Ed", 85), ("MS", 180)]
1159 </programlisting>
1160 </para>
1161 <para>There are three new keywords: <literal>group</literal>, <literal>by</literal>, and <literal>using</literal>.
1162 (The function <literal>sortWith</literal> is not a keyword; it is an ordinary
1163 function that is exported by <literal>GHC.Exts</literal>.)</para>
1164
1165 <para>There are five new forms of comprehension qualifier,
1166 all introduced by the (existing) keyword <literal>then</literal>:
1167     <itemizedlist>
1168     <listitem>
1169     
1170 <programlisting>
1171 then f
1172 </programlisting>
1173
1174     This statement requires that <literal>f</literal> have the type <literal>
1175     forall a. [a] -> [a]</literal>. You can see an example of its use in the
1176     motivating example, as this form is used to apply <literal>take 5</literal>.
1177     
1178     </listitem>
1179     
1180     
1181     <listitem>
1182 <para>
1183 <programlisting>
1184 then f by e
1185 </programlisting>
1186
1187     This form is similar to the previous one, but allows you to create a function
1188     which will be passed as the first argument to f. As a consequence f must have 
1189     the type <literal>forall a. (a -> t) -> [a] -> [a]</literal>. As you can see
1190     from the type, this function lets f &quot;project out&quot; some information 
1191     from the elements of the list it is transforming.</para>
1192
1193     <para>An example is shown in the opening example, where <literal>sortWith</literal> 
1194     is supplied with a function that lets it find out the <literal>sum salary</literal> 
1195     for any item in the list comprehension it transforms.</para>
1196
1197     </listitem>
1198
1199
1200     <listitem>
1201
1202 <programlisting>
1203 then group by e using f
1204 </programlisting>
1205
1206     <para>This is the most general of the grouping-type statements. In this form,
1207     f is required to have type <literal>forall a. (a -> t) -> [a] -> [[a]]</literal>.
1208     As with the <literal>then f by e</literal> case above, the first argument
1209     is a function supplied to f by the compiler which lets it compute e on every
1210     element of the list being transformed. However, unlike the non-grouping case,
1211     f additionally partitions the list into a number of sublists: this means that
1212     at every point after this statement, binders occurring before it in the comprehension
1213     refer to <emphasis>lists</emphasis> of possible values, not single values. To help understand
1214     this, let's look at an example:</para>
1215     
1216 <programlisting>
1217 -- This works similarly to groupWith in GHC.Exts, but doesn't sort its input first
1218 groupRuns :: Eq b => (a -> b) -> [a] -> [[a]]
1219 groupRuns f = groupBy (\x y -> f x == f y)
1220
1221 output = [ (the x, y)
1222 | x &lt;- ([1..3] ++ [1..2])
1223 , y &lt;- [4..6]
1224 , then group by x using groupRuns ]
1225 </programlisting>
1226
1227     <para>This results in the variable <literal>output</literal> taking on the value below:</para>
1228
1229 <programlisting>
1230 [(1, [4, 5, 6]), (2, [4, 5, 6]), (3, [4, 5, 6]), (1, [4, 5, 6]), (2, [4, 5, 6])]
1231 </programlisting>
1232
1233     <para>Note that we have used the <literal>the</literal> function to change the type 
1234     of x from a list to its original numeric type. The variable y, in contrast, is left 
1235     unchanged from the list form introduced by the grouping.</para>
1236
1237     </listitem>
1238
1239     <listitem>
1240
1241 <programlisting>
1242 then group by e
1243 </programlisting>
1244
1245     <para>This form of grouping is essentially the same as the one described above. However,
1246     since no function to use for the grouping has been supplied it will fall back on the
1247     <literal>groupWith</literal> function defined in 
1248     <ulink url="&libraryBaseLocation;/GHC-Exts.html"><literal>GHC.Exts</literal></ulink>. This
1249     is the form of the group statement that we made use of in the opening example.</para>
1250
1251     </listitem>
1252     
1253     
1254     <listitem>
1255
1256 <programlisting>
1257 then group using f
1258 </programlisting>
1259
1260     <para>With this form of the group statement, f is required to simply have the type
1261     <literal>forall a. [a] -> [[a]]</literal>, which will be used to group up the
1262     comprehension so far directly. An example of this form is as follows:</para>
1263     
1264 <programlisting>
1265 output = [ x
1266 | y &lt;- [1..5]
1267 , x &lt;- "hello"
1268 , then group using inits]
1269 </programlisting>
1270
1271     <para>This will yield a list containing every prefix of the word "hello" written out 5 times:</para>
1272
1273 <programlisting>
1274 ["","h","he","hel","hell","hello","helloh","hellohe","hellohel","hellohell","hellohello","hellohelloh",...]
1275 </programlisting>
1276
1277     </listitem>
1278 </itemizedlist>
1279 </para>
1280   </sect2>
1281
1282    <!-- ===================== REBINDABLE SYNTAX ===================  -->
1283
1284 <sect2 id="rebindable-syntax">
1285 <title>Rebindable syntax and the implicit Prelude import</title>
1286
1287  <para><indexterm><primary>-XNoImplicitPrelude
1288  option</primary></indexterm> GHC normally imports
1289  <filename>Prelude.hi</filename> files for you.  If you'd
1290  rather it didn't, then give it a
1291  <option>-XNoImplicitPrelude</option> option.  The idea is
1292  that you can then import a Prelude of your own.  (But don't
1293  call it <literal>Prelude</literal>; the Haskell module
1294  namespace is flat, and you must not conflict with any
1295  Prelude module.)</para>
1296
1297             <para>Suppose you are importing a Prelude of your own
1298               in order to define your own numeric class
1299             hierarchy.  It completely defeats that purpose if the
1300             literal "1" means "<literal>Prelude.fromInteger
1301             1</literal>", which is what the Haskell Report specifies.
1302             So the <option>-XNoImplicitPrelude</option> 
1303               flag <emphasis>also</emphasis> causes
1304             the following pieces of built-in syntax to refer to
1305             <emphasis>whatever is in scope</emphasis>, not the Prelude
1306             versions:
1307             <itemizedlist>
1308               <listitem>
1309                 <para>An integer literal <literal>368</literal> means
1310                 "<literal>fromInteger (368::Integer)</literal>", rather than
1311                 "<literal>Prelude.fromInteger (368::Integer)</literal>".
1312 </para> </listitem>         
1313
1314       <listitem><para>Fractional literals are handed in just the same way,
1315           except that the translation is 
1316               <literal>fromRational (3.68::Rational)</literal>.
1317 </para> </listitem>         
1318
1319           <listitem><para>The equality test in an overloaded numeric pattern
1320               uses whatever <literal>(==)</literal> is in scope.
1321 </para> </listitem>         
1322
1323           <listitem><para>The subtraction operation, and the
1324           greater-than-or-equal test, in <literal>n+k</literal> patterns
1325               use whatever <literal>(-)</literal> and <literal>(>=)</literal> are in scope.
1326               </para></listitem>
1327
1328               <listitem>
1329                 <para>Negation (e.g. "<literal>- (f x)</literal>")
1330                 means "<literal>negate (f x)</literal>", both in numeric
1331                 patterns, and expressions.
1332               </para></listitem>
1333
1334               <listitem>
1335           <para>"Do" notation is translated using whatever
1336               functions <literal>(>>=)</literal>,
1337               <literal>(>>)</literal>, and <literal>fail</literal>,
1338               are in scope (not the Prelude
1339               versions).  List comprehensions, mdo (<xref linkend="mdo-notation"/>), and parallel array
1340               comprehensions, are unaffected.  </para></listitem>
1341
1342               <listitem>
1343                 <para>Arrow
1344                 notation (see <xref linkend="arrow-notation"/>)
1345                 uses whatever <literal>arr</literal>,
1346                 <literal>(>>>)</literal>, <literal>first</literal>,
1347                 <literal>app</literal>, <literal>(|||)</literal> and
1348                 <literal>loop</literal> functions are in scope. But unlike the
1349                 other constructs, the types of these functions must match the
1350                 Prelude types very closely.  Details are in flux; if you want
1351                 to use this, ask!
1352               </para></listitem>
1353             </itemizedlist>
1354 In all cases (apart from arrow notation), the static semantics should be that of the desugared form,
1355 even if that is a little unexpected. For example, the 
1356 static semantics of the literal <literal>368</literal>
1357 is exactly that of <literal>fromInteger (368::Integer)</literal>; it's fine for
1358 <literal>fromInteger</literal> to have any of the types:
1359 <programlisting>
1360 fromInteger :: Integer -> Integer
1361 fromInteger :: forall a. Foo a => Integer -> a
1362 fromInteger :: Num a => a -> Integer
1363 fromInteger :: Integer -> Bool -> Bool
1364 </programlisting>
1365 </para>
1366                 
1367              <para>Be warned: this is an experimental facility, with
1368              fewer checks than usual.  Use <literal>-dcore-lint</literal>
1369              to typecheck the desugared program.  If Core Lint is happy
1370              you should be all right.</para>
1371
1372 </sect2>
1373
1374 <sect2 id="postfix-operators">
1375 <title>Postfix operators</title>
1376
1377 <para>
1378   The <option>-XPostfixOperators</option> flag enables a small
1379 extension to the syntax of left operator sections, which allows you to
1380 define postfix operators.  The extension is this: the left section
1381 <programlisting>
1382   (e !)
1383 </programlisting>
1384 is equivalent (from the point of view of both type checking and execution) to the expression
1385 <programlisting>
1386   ((!) e)
1387 </programlisting>
1388 (for any expression <literal>e</literal> and operator <literal>(!)</literal>.
1389 The strict Haskell 98 interpretation is that the section is equivalent to
1390 <programlisting>
1391   (\y -> (!) e y)
1392 </programlisting>
1393 That is, the operator must be a function of two arguments.  GHC allows it to
1394 take only one argument, and that in turn allows you to write the function
1395 postfix.
1396 </para>
1397 <para>The extension does not extend to the left-hand side of function
1398 definitions; you must define such a function in prefix form.</para>
1399
1400 </sect2>
1401
1402 <sect2 id="tuple-sections">
1403 <title>Tuple sections</title>
1404
1405 <para>
1406   The <option>-XTupleSections</option> flag enables Python-style partially applied
1407   tuple constructors. For example, the following program
1408 <programlisting>
1409   (, True)
1410 </programlisting>
1411   is considered to be an alternative notation for the more unwieldy alternative
1412 <programlisting>
1413   \x -> (x, True)
1414 </programlisting>
1415 You can omit any combination of arguments to the tuple, as in the following
1416 <programlisting>
1417   (, "I", , , "Love", , 1337)
1418 </programlisting>
1419 which translates to
1420 <programlisting>
1421   \a b c d -> (a, "I", b, c, "Love", d, 1337)
1422 </programlisting>
1423 </para>
1424
1425 <para>
1426   If you have <link linkend="unboxed-tuples">unboxed tuples</link> enabled, tuple sections
1427   will also be available for them, like so
1428 <programlisting>
1429   (# , True #)
1430 </programlisting>
1431 Because there is no unboxed unit tuple, the following expression
1432 <programlisting>
1433   (# #)
1434 </programlisting>
1435 continues to stand for the unboxed singleton tuple data constructor.
1436 </para>
1437
1438 </sect2>
1439
1440 <sect2 id="disambiguate-fields">
1441 <title>Record field disambiguation</title>
1442 <para>
1443 In record construction and record pattern matching
1444 it is entirely unambiguous which field is referred to, even if there are two different
1445 data types in scope with a common field name.  For example:
1446 <programlisting>
1447 module M where
1448   data S = MkS { x :: Int, y :: Bool }
1449
1450 module Foo where
1451   import M
1452
1453   data T = MkT { x :: Int }
1454   
1455   ok1 (MkS { x = n }) = n+1   -- Unambiguous
1456   ok2 n = MkT { x = n+1 }     -- Unambiguous
1457
1458   bad1 k = k { x = 3 }  -- Ambiguous
1459   bad2 k = x k          -- Ambiguous
1460 </programlisting>
1461 Even though there are two <literal>x</literal>'s in scope,
1462 it is clear that the <literal>x</literal> in the pattern in the
1463 definition of <literal>ok1</literal> can only mean the field
1464 <literal>x</literal> from type <literal>S</literal>. Similarly for
1465 the function <literal>ok2</literal>.  However, in the record update
1466 in <literal>bad1</literal> and the record selection in <literal>bad2</literal>
1467 it is not clear which of the two types is intended.
1468 </para>
1469 <para>
1470 Haskell 98 regards all four as ambiguous, but with the
1471 <option>-XDisambiguateRecordFields</option> flag, GHC will accept
1472 the former two.  The rules are precisely the same as those for instance
1473 declarations in Haskell 98, where the method names on the left-hand side 
1474 of the method bindings in an instance declaration refer unambiguously
1475 to the method of that class (provided they are in scope at all), even
1476 if there are other variables in scope with the same name.
1477 This reduces the clutter of qualified names when you import two
1478 records from different modules that use the same field name.
1479 </para>
1480 <para>
1481 Some details:
1482 <itemizedlist>
1483 <listitem><para>
1484 Field disambiguation can be combined with punning (see <xref linkend="record-puns"/>). For exampe:
1485 <programlisting>
1486 module Foo where
1487   import M
1488   x=True
1489   ok3 (MkS { x }) = x+1   -- Uses both disambiguation and punning
1490 </programlisting>
1491 </para></listitem>
1492
1493 <listitem><para>
1494 With <option>-XDisambiguateRecordFields</option> you can use <emphasis>unqualifed</emphasis>
1495 field names even if the correponding selector is only in scope <emphasis>qualified</emphasis>
1496 For example, assuming the same module <literal>M</literal> as in our earlier example, this is legal:
1497 <programlisting>
1498 module Foo where
1499   import qualified M    -- Note qualified
1500
1501   ok4 (M.MkS { x = n }) = n+1   -- Unambiguous
1502 </programlisting>
1503 Since the constructore <literal>MkS</literal> is only in scope qualified, you must
1504 name it <literal>M.MkS</literal>, but the field <literal>x</literal> does not need
1505 to be qualified even though <literal>M.x</literal> is in scope but <literal>x</literal>
1506 is not.  (In effect, it is qualified by the constructor.)
1507 </para></listitem>
1508 </itemizedlist>
1509 </para>
1510
1511 </sect2>
1512
1513     <!-- ===================== Record puns ===================  -->
1514
1515 <sect2 id="record-puns">
1516 <title>Record puns
1517 </title>
1518
1519 <para>
1520 Record puns are enabled by the flag <literal>-XNamedFieldPuns</literal>.
1521 </para>
1522
1523 <para>
1524 When using records, it is common to write a pattern that binds a
1525 variable with the same name as a record field, such as:
1526
1527 <programlisting>
1528 data C = C {a :: Int}
1529 f (C {a = a}) = a
1530 </programlisting>
1531 </para>
1532
1533 <para>
1534 Record punning permits the variable name to be elided, so one can simply
1535 write
1536
1537 <programlisting>
1538 f (C {a}) = a
1539 </programlisting>
1540
1541 to mean the same pattern as above.  That is, in a record pattern, the
1542 pattern <literal>a</literal> expands into the pattern <literal>a =
1543 a</literal> for the same name <literal>a</literal>.  
1544 </para>
1545
1546 <para>
1547 Note that:
1548 <itemizedlist>
1549 <listitem><para>
1550 Record punning can also be used in an expression, writing, for example,
1551 <programlisting>
1552 let a = 1 in C {a}
1553 </programlisting>
1554 instead of 
1555 <programlisting>
1556 let a = 1 in C {a = a}
1557 </programlisting>
1558 The expansion is purely syntactic, so the expanded right-hand side
1559 expression refers to the nearest enclosing variable that is spelled the
1560 same as the field name.
1561 </para></listitem>
1562
1563 <listitem><para>
1564 Puns and other patterns can be mixed in the same record:
1565 <programlisting>
1566 data C = C {a :: Int, b :: Int}
1567 f (C {a, b = 4}) = a
1568 </programlisting>
1569 </para></listitem>
1570
1571 <listitem><para>
1572 Puns can be used wherever record patterns occur (e.g. in
1573 <literal>let</literal> bindings or at the top-level).  
1574 </para></listitem>
1575
1576 <listitem><para>
1577 A pun on a qualified field name is expanded by stripping off the module qualifier.
1578 For example:
1579 <programlisting>
1580 f (C {M.a}) = a
1581 </programlisting>
1582 means
1583 <programlisting>
1584 f (M.C {M.a = a}) = a
1585 </programlisting>
1586 (This is useful if the field selector <literal>a</literal> for constructor <literal>M.C</literal>
1587 is only in scope in qualified form.)
1588 </para></listitem>
1589 </itemizedlist>
1590 </para>
1591
1592
1593 </sect2>
1594
1595     <!-- ===================== Record wildcards ===================  -->
1596
1597 <sect2 id="record-wildcards">
1598 <title>Record wildcards
1599 </title>
1600
1601 <para>
1602 Record wildcards are enabled by the flag <literal>-XRecordWildCards</literal>.
1603 This flag implies <literal>-XDisambiguateRecordFields</literal>.
1604 </para>
1605
1606 <para>
1607 For records with many fields, it can be tiresome to write out each field
1608 individually in a record pattern, as in
1609 <programlisting>
1610 data C = C {a :: Int, b :: Int, c :: Int, d :: Int}
1611 f (C {a = 1, b = b, c = c, d = d}) = b + c + d
1612 </programlisting>
1613 </para>
1614
1615 <para>
1616 Record wildcard syntax permits a "<literal>..</literal>" in a record
1617 pattern, where each elided field <literal>f</literal> is replaced by the
1618 pattern <literal>f = f</literal>.  For example, the above pattern can be
1619 written as
1620 <programlisting>
1621 f (C {a = 1, ..}) = b + c + d
1622 </programlisting>
1623 </para>
1624
1625 <para>
1626 More details:
1627 <itemizedlist>
1628 <listitem><para>
1629 Wildcards can be mixed with other patterns, including puns
1630 (<xref linkend="record-puns"/>); for example, in a pattern <literal>C {a
1631 = 1, b, ..})</literal>.  Additionally, record wildcards can be used
1632 wherever record patterns occur, including in <literal>let</literal>
1633 bindings and at the top-level.  For example, the top-level binding
1634 <programlisting>
1635 C {a = 1, ..} = e
1636 </programlisting>
1637 defines <literal>b</literal>, <literal>c</literal>, and
1638 <literal>d</literal>.
1639 </para></listitem>
1640
1641 <listitem><para>
1642 Record wildcards can also be used in expressions, writing, for example,
1643 <programlisting>
1644 let {a = 1; b = 2; c = 3; d = 4} in C {..}
1645 </programlisting>
1646 in place of
1647 <programlisting>
1648 let {a = 1; b = 2; c = 3; d = 4} in C {a=a, b=b, c=c, d=d}
1649 </programlisting>
1650 The expansion is purely syntactic, so the record wildcard
1651 expression refers to the nearest enclosing variables that are spelled
1652 the same as the omitted field names.
1653 </para></listitem>
1654
1655 <listitem><para>
1656 The "<literal>..</literal>" expands to the missing 
1657 <emphasis>in-scope</emphasis> record fields, where "in scope"
1658 includes both unqualified and qualified-only.  
1659 Any fields that are not in scope are not filled in.  For example
1660 <programlisting>
1661 module M where
1662   data R = R { a,b,c :: Int }
1663 module X where
1664   import qualified M( R(a,b) )
1665   f a b = R { .. }
1666 </programlisting>
1667 The <literal>{..}</literal> expands to <literal>{M.a=a,M.b=b}</literal>,
1668 omitting <literal>c</literal> since it is not in scope at all.
1669 </para></listitem>
1670 </itemizedlist>
1671 </para>
1672
1673 </sect2>
1674
1675     <!-- ===================== Local fixity declarations ===================  -->
1676
1677 <sect2 id="local-fixity-declarations">
1678 <title>Local Fixity Declarations
1679 </title>
1680
1681 <para>A careful reading of the Haskell 98 Report reveals that fixity
1682 declarations (<literal>infix</literal>, <literal>infixl</literal>, and
1683 <literal>infixr</literal>) are permitted to appear inside local bindings
1684 such those introduced by <literal>let</literal> and
1685 <literal>where</literal>.  However, the Haskell Report does not specify
1686 the semantics of such bindings very precisely.
1687 </para>
1688
1689 <para>In GHC, a fixity declaration may accompany a local binding:
1690 <programlisting>
1691 let f = ...
1692     infixr 3 `f`
1693 in 
1694     ...
1695 </programlisting>
1696 and the fixity declaration applies wherever the binding is in scope.
1697 For example, in a <literal>let</literal>, it applies in the right-hand
1698 sides of other <literal>let</literal>-bindings and the body of the
1699 <literal>let</literal>C. Or, in recursive <literal>do</literal>
1700 expressions (<xref linkend="recursive-do-notation"/>), the local fixity
1701 declarations of a <literal>let</literal> statement scope over other
1702 statements in the group, just as the bound name does.
1703 </para>
1704
1705 <para>
1706 Moreover, a local fixity declaration *must* accompany a local binding of
1707 that name: it is not possible to revise the fixity of name bound
1708 elsewhere, as in
1709 <programlisting>
1710 let infixr 9 $ in ...
1711 </programlisting>
1712
1713 Because local fixity declarations are technically Haskell 98, no flag is
1714 necessary to enable them.
1715 </para>
1716 </sect2>
1717
1718 <sect2 id="package-imports">
1719   <title>Package-qualified imports</title>
1720
1721   <para>With the <option>-XPackageImports</option> flag, GHC allows
1722   import declarations to be qualified by the package name that the
1723     module is intended to be imported from.  For example:</para>
1724
1725 <programlisting>
1726 import "network" Network.Socket
1727 </programlisting>
1728   
1729   <para>would import the module <literal>Network.Socket</literal> from
1730     the package <literal>network</literal> (any version).  This may
1731     be used to disambiguate an import when the same module is
1732     available from multiple packages, or is present in both the
1733     current package being built and an external package.</para>
1734
1735   <para>Note: you probably don't need to use this feature, it was
1736     added mainly so that we can build backwards-compatible versions of
1737     packages when APIs change.  It can lead to fragile dependencies in
1738     the common case: modules occasionally move from one package to
1739     another, rendering any package-qualified imports broken.</para>
1740 </sect2>
1741
1742 <sect2 id="syntax-stolen">
1743 <title>Summary of stolen syntax</title>
1744
1745     <para>Turning on an option that enables special syntax
1746     <emphasis>might</emphasis> cause working Haskell 98 code to fail
1747     to compile, perhaps because it uses a variable name which has
1748     become a reserved word.  This section lists the syntax that is
1749     "stolen" by language extensions.
1750      We use
1751     notation and nonterminal names from the Haskell 98 lexical syntax
1752     (see the Haskell 98 Report).  
1753     We only list syntax changes here that might affect
1754     existing working programs (i.e. "stolen" syntax).  Many of these
1755     extensions will also enable new context-free syntax, but in all
1756     cases programs written to use the new syntax would not be
1757     compilable without the option enabled.</para>
1758
1759 <para>There are two classes of special
1760     syntax:
1761
1762     <itemizedlist>
1763       <listitem>
1764         <para>New reserved words and symbols: character sequences
1765         which are no longer available for use as identifiers in the
1766         program.</para>
1767       </listitem>
1768       <listitem>
1769         <para>Other special syntax: sequences of characters that have
1770         a different meaning when this particular option is turned
1771         on.</para>
1772       </listitem>
1773     </itemizedlist>
1774     
1775 The following syntax is stolen:
1776
1777     <variablelist>
1778       <varlistentry>
1779         <term>
1780           <literal>forall</literal>
1781           <indexterm><primary><literal>forall</literal></primary></indexterm>
1782         </term>
1783         <listitem><para>
1784         Stolen (in types) by: <option>-XExplicitForAll</option>, and hence by
1785             <option>-XScopedTypeVariables</option>,
1786             <option>-XLiberalTypeSynonyms</option>,
1787             <option>-XRank2Types</option>,
1788             <option>-XRankNTypes</option>,
1789             <option>-XPolymorphicComponents</option>,
1790             <option>-XExistentialQuantification</option>
1791           </para></listitem>
1792       </varlistentry>
1793
1794       <varlistentry>
1795         <term>
1796           <literal>mdo</literal>
1797           <indexterm><primary><literal>mdo</literal></primary></indexterm>
1798         </term>
1799         <listitem><para>
1800         Stolen by: <option>-XRecursiveDo</option>,
1801           </para></listitem>
1802       </varlistentry>
1803
1804       <varlistentry>
1805         <term>
1806           <literal>foreign</literal>
1807           <indexterm><primary><literal>foreign</literal></primary></indexterm>
1808         </term>
1809         <listitem><para>
1810         Stolen by: <option>-XForeignFunctionInterface</option>,
1811           </para></listitem>
1812       </varlistentry>
1813
1814       <varlistentry>
1815         <term>
1816           <literal>rec</literal>,
1817           <literal>proc</literal>, <literal>-&lt;</literal>,
1818           <literal>&gt;-</literal>, <literal>-&lt;&lt;</literal>,
1819           <literal>&gt;&gt;-</literal>, and <literal>(|</literal>,
1820           <literal>|)</literal> brackets
1821           <indexterm><primary><literal>proc</literal></primary></indexterm>
1822         </term>
1823         <listitem><para>
1824         Stolen by: <option>-XArrows</option>,
1825           </para></listitem>
1826       </varlistentry>
1827
1828       <varlistentry>
1829         <term>
1830           <literal>?<replaceable>varid</replaceable></literal>,
1831           <literal>%<replaceable>varid</replaceable></literal>
1832           <indexterm><primary>implicit parameters</primary></indexterm>
1833         </term>
1834         <listitem><para>
1835         Stolen by: <option>-XImplicitParams</option>,
1836           </para></listitem>
1837       </varlistentry>
1838
1839       <varlistentry>
1840         <term>
1841           <literal>[|</literal>,
1842           <literal>[e|</literal>, <literal>[p|</literal>,
1843           <literal>[d|</literal>, <literal>[t|</literal>,
1844           <literal>$(</literal>,
1845           <literal>$<replaceable>varid</replaceable></literal>
1846           <indexterm><primary>Template Haskell</primary></indexterm>
1847         </term>
1848         <listitem><para>
1849         Stolen by: <option>-XTemplateHaskell</option>,
1850           </para></listitem>
1851       </varlistentry>
1852
1853       <varlistentry>
1854         <term>
1855           <literal>[:<replaceable>varid</replaceable>|</literal>
1856           <indexterm><primary>quasi-quotation</primary></indexterm>
1857         </term>
1858         <listitem><para>
1859         Stolen by: <option>-XQuasiQuotes</option>,
1860           </para></listitem>
1861       </varlistentry>
1862
1863       <varlistentry>
1864         <term>
1865               <replaceable>varid</replaceable>{<literal>&num;</literal>},
1866               <replaceable>char</replaceable><literal>&num;</literal>,      
1867               <replaceable>string</replaceable><literal>&num;</literal>,    
1868               <replaceable>integer</replaceable><literal>&num;</literal>,    
1869               <replaceable>float</replaceable><literal>&num;</literal>,    
1870               <replaceable>float</replaceable><literal>&num;&num;</literal>,    
1871               <literal>(&num;</literal>, <literal>&num;)</literal>,         
1872         </term>
1873         <listitem><para>
1874         Stolen by: <option>-XMagicHash</option>,
1875           </para></listitem>
1876       </varlistentry>
1877     </variablelist>
1878 </para>
1879 </sect2>
1880 </sect1>
1881
1882
1883 <!-- TYPE SYSTEM EXTENSIONS -->
1884 <sect1 id="data-type-extensions">
1885 <title>Extensions to data types and type synonyms</title>
1886
1887 <sect2 id="nullary-types">
1888 <title>Data types with no constructors</title>
1889
1890 <para>With the <option>-fglasgow-exts</option> flag, GHC lets you declare
1891 a data type with no constructors.  For example:</para>
1892
1893 <programlisting>
1894   data S      -- S :: *
1895   data T a    -- T :: * -> *
1896 </programlisting>
1897
1898 <para>Syntactically, the declaration lacks the "= constrs" part.  The 
1899 type can be parameterised over types of any kind, but if the kind is
1900 not <literal>*</literal> then an explicit kind annotation must be used
1901 (see <xref linkend="kinding"/>).</para>
1902
1903 <para>Such data types have only one value, namely bottom.
1904 Nevertheless, they can be useful when defining "phantom types".</para>
1905 </sect2>
1906
1907 <sect2 id="infix-tycons">
1908 <title>Infix type constructors, classes, and type variables</title>
1909
1910 <para>
1911 GHC allows type constructors, classes, and type variables to be operators, and
1912 to be written infix, very much like expressions.  More specifically:
1913 <itemizedlist>
1914 <listitem><para>
1915   A type constructor or class can be an operator, beginning with a colon; e.g. <literal>:*:</literal>.
1916   The lexical syntax is the same as that for data constructors.
1917   </para></listitem>
1918 <listitem><para>
1919   Data type and type-synonym declarations can be written infix, parenthesised
1920   if you want further arguments.  E.g.
1921 <screen>
1922   data a :*: b = Foo a b
1923   type a :+: b = Either a b
1924   class a :=: b where ...
1925
1926   data (a :**: b) x = Baz a b x
1927   type (a :++: b) y = Either (a,b) y
1928 </screen>
1929   </para></listitem>
1930 <listitem><para>
1931   Types, and class constraints, can be written infix.  For example
1932   <screen>
1933         x :: Int :*: Bool
1934         f :: (a :=: b) => a -> b
1935   </screen>
1936   </para></listitem>
1937 <listitem><para>
1938   A type variable can be an (unqualified) operator e.g. <literal>+</literal>.
1939   The lexical syntax is the same as that for variable operators, excluding "(.)",
1940   "(!)", and "(*)".  In a binding position, the operator must be
1941   parenthesised.  For example:
1942 <programlisting>
1943    type T (+) = Int + Int
1944    f :: T Either
1945    f = Left 3
1946  
1947    liftA2 :: Arrow (~>)
1948           => (a -> b -> c) -> (e ~> a) -> (e ~> b) -> (e ~> c)
1949    liftA2 = ...
1950 </programlisting>
1951   </para></listitem>
1952 <listitem><para>
1953   Back-quotes work
1954   as for expressions, both for type constructors and type variables;  e.g. <literal>Int `Either` Bool</literal>, or
1955   <literal>Int `a` Bool</literal>.  Similarly, parentheses work the same; e.g.  <literal>(:*:) Int Bool</literal>.
1956   </para></listitem>
1957 <listitem><para>
1958   Fixities may be declared for type constructors, or classes, just as for data constructors.  However,
1959   one cannot distinguish between the two in a fixity declaration; a fixity declaration
1960   sets the fixity for a data constructor and the corresponding type constructor.  For example:
1961 <screen>
1962   infixl 7 T, :*:
1963 </screen>
1964   sets the fixity for both type constructor <literal>T</literal> and data constructor <literal>T</literal>,
1965   and similarly for <literal>:*:</literal>.
1966   <literal>Int `a` Bool</literal>.
1967   </para></listitem>
1968 <listitem><para>
1969   Function arrow is <literal>infixr</literal> with fixity 0.  (This might change; I'm not sure what it should be.)
1970   </para></listitem>
1971
1972 </itemizedlist>
1973 </para>
1974 </sect2>
1975
1976 <sect2 id="type-synonyms">
1977 <title>Liberalised type synonyms</title>
1978
1979 <para>
1980 Type synonyms are like macros at the type level, but Haskell 98 imposes many rules
1981 on individual synonym declarations.
1982 With the <option>-XLiberalTypeSynonyms</option> extension,
1983 GHC does validity checking on types <emphasis>only after expanding type synonyms</emphasis>.
1984 That means that GHC can be very much more liberal about type synonyms than Haskell 98. 
1985
1986 <itemizedlist>
1987 <listitem> <para>You can write a <literal>forall</literal> (including overloading)
1988 in a type synonym, thus:
1989 <programlisting>
1990   type Discard a = forall b. Show b => a -> b -> (a, String)
1991
1992   f :: Discard a
1993   f x y = (x, show y)
1994
1995   g :: Discard Int -> (Int,String)    -- A rank-2 type
1996   g f = f 3 True
1997 </programlisting>
1998 </para>
1999 </listitem>
2000
2001 <listitem><para>
2002 If you also use <option>-XUnboxedTuples</option>, 
2003 you can write an unboxed tuple in a type synonym:
2004 <programlisting>
2005   type Pr = (# Int, Int #)
2006
2007   h :: Int -> Pr
2008   h x = (# x, x #)
2009 </programlisting>
2010 </para></listitem>
2011
2012 <listitem><para>
2013 You can apply a type synonym to a forall type:
2014 <programlisting>
2015   type Foo a = a -> a -> Bool
2016  
2017   f :: Foo (forall b. b->b)
2018 </programlisting>
2019 After expanding the synonym, <literal>f</literal> has the legal (in GHC) type:
2020 <programlisting>
2021   f :: (forall b. b->b) -> (forall b. b->b) -> Bool
2022 </programlisting>
2023 </para></listitem>
2024
2025 <listitem><para>
2026 You can apply a type synonym to a partially applied type synonym:
2027 <programlisting>
2028   type Generic i o = forall x. i x -> o x
2029   type Id x = x
2030   
2031   foo :: Generic Id []
2032 </programlisting>
2033 After expanding the synonym, <literal>foo</literal> has the legal (in GHC) type:
2034 <programlisting>
2035   foo :: forall x. x -> [x]
2036 </programlisting>
2037 </para></listitem>
2038
2039 </itemizedlist>
2040 </para>
2041
2042 <para>
2043 GHC currently does kind checking before expanding synonyms (though even that
2044 could be changed.)
2045 </para>
2046 <para>
2047 After expanding type synonyms, GHC does validity checking on types, looking for
2048 the following mal-formedness which isn't detected simply by kind checking:
2049 <itemizedlist>
2050 <listitem><para>
2051 Type constructor applied to a type involving for-alls.
2052 </para></listitem>
2053 <listitem><para>
2054 Unboxed tuple on left of an arrow.
2055 </para></listitem>
2056 <listitem><para>
2057 Partially-applied type synonym.
2058 </para></listitem>
2059 </itemizedlist>
2060 So, for example,
2061 this will be rejected:
2062 <programlisting>
2063   type Pr = (# Int, Int #)
2064
2065   h :: Pr -> Int
2066   h x = ...
2067 </programlisting>
2068 because GHC does not allow  unboxed tuples on the left of a function arrow.
2069 </para>
2070 </sect2>
2071
2072
2073 <sect2 id="existential-quantification">
2074 <title>Existentially quantified data constructors
2075 </title>
2076
2077 <para>
2078 The idea of using existential quantification in data type declarations
2079 was suggested by Perry, and implemented in Hope+ (Nigel Perry, <emphasis>The Implementation
2080 of Practical Functional Programming Languages</emphasis>, PhD Thesis, University of
2081 London, 1991). It was later formalised by Laufer and Odersky
2082 (<emphasis>Polymorphic type inference and abstract data types</emphasis>,
2083 TOPLAS, 16(5), pp1411-1430, 1994).
2084 It's been in Lennart
2085 Augustsson's <command>hbc</command> Haskell compiler for several years, and
2086 proved very useful.  Here's the idea.  Consider the declaration:
2087 </para>
2088
2089 <para>
2090
2091 <programlisting>
2092   data Foo = forall a. MkFoo a (a -> Bool)
2093            | Nil
2094 </programlisting>
2095
2096 </para>
2097
2098 <para>
2099 The data type <literal>Foo</literal> has two constructors with types:
2100 </para>
2101
2102 <para>
2103
2104 <programlisting>
2105   MkFoo :: forall a. a -> (a -> Bool) -> Foo
2106   Nil   :: Foo
2107 </programlisting>
2108
2109 </para>
2110
2111 <para>
2112 Notice that the type variable <literal>a</literal> in the type of <function>MkFoo</function>
2113 does not appear in the data type itself, which is plain <literal>Foo</literal>.
2114 For example, the following expression is fine:
2115 </para>
2116
2117 <para>
2118
2119 <programlisting>
2120   [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
2121 </programlisting>
2122
2123 </para>
2124
2125 <para>
2126 Here, <literal>(MkFoo 3 even)</literal> packages an integer with a function
2127 <function>even</function> that maps an integer to <literal>Bool</literal>; and <function>MkFoo 'c'
2128 isUpper</function> packages a character with a compatible function.  These
2129 two things are each of type <literal>Foo</literal> and can be put in a list.
2130 </para>
2131
2132 <para>
2133 What can we do with a value of type <literal>Foo</literal>?.  In particular,
2134 what happens when we pattern-match on <function>MkFoo</function>?
2135 </para>
2136
2137 <para>
2138
2139 <programlisting>
2140   f (MkFoo val fn) = ???
2141 </programlisting>
2142
2143 </para>
2144
2145 <para>
2146 Since all we know about <literal>val</literal> and <function>fn</function> is that they
2147 are compatible, the only (useful) thing we can do with them is to
2148 apply <function>fn</function> to <literal>val</literal> to get a boolean.  For example:
2149 </para>
2150
2151 <para>
2152
2153 <programlisting>
2154   f :: Foo -> Bool
2155   f (MkFoo val fn) = fn val
2156 </programlisting>
2157
2158 </para>
2159
2160 <para>
2161 What this allows us to do is to package heterogeneous values
2162 together with a bunch of functions that manipulate them, and then treat
2163 that collection of packages in a uniform manner.  You can express
2164 quite a bit of object-oriented-like programming this way.
2165 </para>
2166
2167 <sect3 id="existential">
2168 <title>Why existential?
2169 </title>
2170
2171 <para>
2172 What has this to do with <emphasis>existential</emphasis> quantification?
2173 Simply that <function>MkFoo</function> has the (nearly) isomorphic type
2174 </para>
2175
2176 <para>
2177
2178 <programlisting>
2179   MkFoo :: (exists a . (a, a -> Bool)) -> Foo
2180 </programlisting>
2181
2182 </para>
2183
2184 <para>
2185 But Haskell programmers can safely think of the ordinary
2186 <emphasis>universally</emphasis> quantified type given above, thereby avoiding
2187 adding a new existential quantification construct.
2188 </para>
2189
2190 </sect3>
2191
2192 <sect3 id="existential-with-context">
2193 <title>Existentials and type classes</title>
2194
2195 <para>
2196 An easy extension is to allow
2197 arbitrary contexts before the constructor.  For example:
2198 </para>
2199
2200 <para>
2201
2202 <programlisting>
2203 data Baz = forall a. Eq a => Baz1 a a
2204          | forall b. Show b => Baz2 b (b -> b)
2205 </programlisting>
2206
2207 </para>
2208
2209 <para>
2210 The two constructors have the types you'd expect:
2211 </para>
2212
2213 <para>
2214
2215 <programlisting>
2216 Baz1 :: forall a. Eq a => a -> a -> Baz
2217 Baz2 :: forall b. Show b => b -> (b -> b) -> Baz
2218 </programlisting>
2219
2220 </para>
2221
2222 <para>
2223 But when pattern matching on <function>Baz1</function> the matched values can be compared
2224 for equality, and when pattern matching on <function>Baz2</function> the first matched
2225 value can be converted to a string (as well as applying the function to it).
2226 So this program is legal:
2227 </para>
2228
2229 <para>
2230
2231 <programlisting>
2232   f :: Baz -> String
2233   f (Baz1 p q) | p == q    = "Yes"
2234                | otherwise = "No"
2235   f (Baz2 v fn)            = show (fn v)
2236 </programlisting>
2237
2238 </para>
2239
2240 <para>
2241 Operationally, in a dictionary-passing implementation, the
2242 constructors <function>Baz1</function> and <function>Baz2</function> must store the
2243 dictionaries for <literal>Eq</literal> and <literal>Show</literal> respectively, and
2244 extract it on pattern matching.
2245 </para>
2246
2247 </sect3>
2248
2249 <sect3 id="existential-records">
2250 <title>Record Constructors</title>
2251
2252 <para>
2253 GHC allows existentials to be used with records syntax as well.  For example:
2254
2255 <programlisting>
2256 data Counter a = forall self. NewCounter
2257     { _this    :: self
2258     , _inc     :: self -> self
2259     , _display :: self -> IO ()
2260     , tag      :: a
2261     }
2262 </programlisting>
2263 Here <literal>tag</literal> is a public field, with a well-typed selector
2264 function <literal>tag :: Counter a -> a</literal>.  The <literal>self</literal>
2265 type is hidden from the outside; any attempt to apply <literal>_this</literal>,
2266 <literal>_inc</literal> or <literal>_display</literal> as functions will raise a
2267 compile-time error.  In other words, <emphasis>GHC defines a record selector function
2268 only for fields whose type does not mention the existentially-quantified variables</emphasis>.
2269 (This example used an underscore in the fields for which record selectors
2270 will not be defined, but that is only programming style; GHC ignores them.)
2271 </para>
2272
2273 <para>
2274 To make use of these hidden fields, we need to create some helper functions:
2275
2276 <programlisting>
2277 inc :: Counter a -> Counter a
2278 inc (NewCounter x i d t) = NewCounter
2279     { _this = i x, _inc = i, _display = d, tag = t } 
2280
2281 display :: Counter a -> IO ()
2282 display NewCounter{ _this = x, _display = d } = d x
2283 </programlisting>
2284
2285 Now we can define counters with different underlying implementations:
2286
2287 <programlisting>
2288 counterA :: Counter String 
2289 counterA = NewCounter
2290     { _this = 0, _inc = (1+), _display = print, tag = "A" }
2291
2292 counterB :: Counter String 
2293 counterB = NewCounter
2294     { _this = "", _inc = ('#':), _display = putStrLn, tag = "B" }
2295
2296 main = do
2297     display (inc counterA)         -- prints "1"
2298     display (inc (inc counterB))   -- prints "##"
2299 </programlisting>
2300
2301 Record update syntax is supported for existentials (and GADTs):
2302 <programlisting>
2303 setTag :: Counter a -> a -> Counter a
2304 setTag obj t = obj{ tag = t }
2305 </programlisting>
2306 The rule for record update is this: <emphasis>
2307 the types of the updated fields may
2308 mention only the universally-quantified type variables
2309 of the data constructor.  For GADTs, the field may mention only types
2310 that appear as a simple type-variable argument in the constructor's result
2311 type</emphasis>.  For example:
2312 <programlisting>
2313 data T a b where { T1 { f1::a, f2::b, f3::(b,c) } :: T a b } -- c is existential
2314 upd1 t x = t { f1=x }   -- OK:   upd1 :: T a b -> a' -> T a' b
2315 upd2 t x = t { f3=x }   -- BAD   (f3's type mentions c, which is
2316                         --        existentially quantified)
2317
2318 data G a b where { G1 { g1::a, g2::c } :: G a [c] }
2319 upd3 g x = g { g1=x }   -- OK:   upd3 :: G a b -> c -> G c b
2320 upd4 g x = g { g2=x }   -- BAD (f2's type mentions c, which is not a simple
2321                         --      type-variable argument in G1's result type)
2322 </programlisting>
2323 </para>
2324
2325 </sect3>
2326
2327
2328 <sect3>
2329 <title>Restrictions</title>
2330
2331 <para>
2332 There are several restrictions on the ways in which existentially-quantified
2333 constructors can be use.
2334 </para>
2335
2336 <para>
2337
2338 <itemizedlist>
2339 <listitem>
2340
2341 <para>
2342  When pattern matching, each pattern match introduces a new,
2343 distinct, type for each existential type variable.  These types cannot
2344 be unified with any other type, nor can they escape from the scope of
2345 the pattern match.  For example, these fragments are incorrect:
2346
2347
2348 <programlisting>
2349 f1 (MkFoo a f) = a
2350 </programlisting>
2351
2352
2353 Here, the type bound by <function>MkFoo</function> "escapes", because <literal>a</literal>
2354 is the result of <function>f1</function>.  One way to see why this is wrong is to
2355 ask what type <function>f1</function> has:
2356
2357
2358 <programlisting>
2359   f1 :: Foo -> a             -- Weird!
2360 </programlisting>
2361
2362
2363 What is this "<literal>a</literal>" in the result type? Clearly we don't mean
2364 this:
2365
2366
2367 <programlisting>
2368   f1 :: forall a. Foo -> a   -- Wrong!
2369 </programlisting>
2370
2371
2372 The original program is just plain wrong.  Here's another sort of error
2373
2374
2375 <programlisting>
2376   f2 (Baz1 a b) (Baz1 p q) = a==q
2377 </programlisting>
2378
2379
2380 It's ok to say <literal>a==b</literal> or <literal>p==q</literal>, but
2381 <literal>a==q</literal> is wrong because it equates the two distinct types arising
2382 from the two <function>Baz1</function> constructors.
2383
2384
2385 </para>
2386 </listitem>
2387 <listitem>
2388
2389 <para>
2390 You can't pattern-match on an existentially quantified
2391 constructor in a <literal>let</literal> or <literal>where</literal> group of
2392 bindings. So this is illegal:
2393
2394
2395 <programlisting>
2396   f3 x = a==b where { Baz1 a b = x }
2397 </programlisting>
2398
2399 Instead, use a <literal>case</literal> expression:
2400
2401 <programlisting>
2402   f3 x = case x of Baz1 a b -> a==b
2403 </programlisting>
2404
2405 In general, you can only pattern-match
2406 on an existentially-quantified constructor in a <literal>case</literal> expression or
2407 in the patterns of a function definition.
2408
2409 The reason for this restriction is really an implementation one.
2410 Type-checking binding groups is already a nightmare without
2411 existentials complicating the picture.  Also an existential pattern
2412 binding at the top level of a module doesn't make sense, because it's
2413 not clear how to prevent the existentially-quantified type "escaping".
2414 So for now, there's a simple-to-state restriction.  We'll see how
2415 annoying it is.
2416
2417 </para>
2418 </listitem>
2419 <listitem>
2420
2421 <para>
2422 You can't use existential quantification for <literal>newtype</literal>
2423 declarations.  So this is illegal:
2424
2425
2426 <programlisting>
2427   newtype T = forall a. Ord a => MkT a
2428 </programlisting>
2429
2430
2431 Reason: a value of type <literal>T</literal> must be represented as a
2432 pair of a dictionary for <literal>Ord t</literal> and a value of type
2433 <literal>t</literal>.  That contradicts the idea that
2434 <literal>newtype</literal> should have no concrete representation.
2435 You can get just the same efficiency and effect by using
2436 <literal>data</literal> instead of <literal>newtype</literal>.  If
2437 there is no overloading involved, then there is more of a case for
2438 allowing an existentially-quantified <literal>newtype</literal>,
2439 because the <literal>data</literal> version does carry an
2440 implementation cost, but single-field existentially quantified
2441 constructors aren't much use.  So the simple restriction (no
2442 existential stuff on <literal>newtype</literal>) stands, unless there
2443 are convincing reasons to change it.
2444
2445
2446 </para>
2447 </listitem>
2448 <listitem>
2449
2450 <para>
2451  You can't use <literal>deriving</literal> to define instances of a
2452 data type with existentially quantified data constructors.
2453
2454 Reason: in most cases it would not make sense. For example:;
2455
2456 <programlisting>
2457 data T = forall a. MkT [a] deriving( Eq )
2458 </programlisting>
2459
2460 To derive <literal>Eq</literal> in the standard way we would need to have equality
2461 between the single component of two <function>MkT</function> constructors:
2462
2463 <programlisting>
2464 instance Eq T where
2465   (MkT a) == (MkT b) = ???
2466 </programlisting>
2467
2468 But <varname>a</varname> and <varname>b</varname> have distinct types, and so can't be compared.
2469 It's just about possible to imagine examples in which the derived instance
2470 would make sense, but it seems altogether simpler simply to prohibit such
2471 declarations.  Define your own instances!
2472 </para>
2473 </listitem>
2474
2475 </itemizedlist>
2476
2477 </para>
2478
2479 </sect3>
2480 </sect2>
2481
2482 <!-- ====================== Generalised algebraic data types =======================  -->
2483
2484 <sect2 id="gadt-style">
2485 <title>Declaring data types with explicit constructor signatures</title>
2486
2487 <para>GHC allows you to declare an algebraic data type by 
2488 giving the type signatures of constructors explicitly.  For example:
2489 <programlisting>
2490   data Maybe a where
2491       Nothing :: Maybe a
2492       Just    :: a -> Maybe a
2493 </programlisting>
2494 The form is called a "GADT-style declaration"
2495 because Generalised Algebraic Data Types, described in <xref linkend="gadt"/>, 
2496 can only be declared using this form.</para>
2497 <para>Notice that GADT-style syntax generalises existential types (<xref linkend="existential-quantification"/>).  
2498 For example, these two declarations are equivalent:
2499 <programlisting>
2500   data Foo = forall a. MkFoo a (a -> Bool)
2501   data Foo' where { MKFoo :: a -> (a->Bool) -> Foo' }
2502 </programlisting>
2503 </para>
2504 <para>Any data type that can be declared in standard Haskell-98 syntax 
2505 can also be declared using GADT-style syntax.
2506 The choice is largely stylistic, but GADT-style declarations differ in one important respect:
2507 they treat class constraints on the data constructors differently.
2508 Specifically, if the constructor is given a type-class context, that
2509 context is made available by pattern matching.  For example:
2510 <programlisting>
2511   data Set a where
2512     MkSet :: Eq a => [a] -> Set a
2513
2514   makeSet :: Eq a => [a] -> Set a
2515   makeSet xs = MkSet (nub xs)
2516
2517   insert :: a -> Set a -> Set a
2518   insert a (MkSet as) | a `elem` as = MkSet as
2519                       | otherwise   = MkSet (a:as)
2520 </programlisting>
2521 A use of <literal>MkSet</literal> as a constructor (e.g. in the definition of <literal>makeSet</literal>) 
2522 gives rise to a <literal>(Eq a)</literal>
2523 constraint, as you would expect.  The new feature is that pattern-matching on <literal>MkSet</literal>
2524 (as in the definition of <literal>insert</literal>) makes <emphasis>available</emphasis> an <literal>(Eq a)</literal>
2525 context.  In implementation terms, the <literal>MkSet</literal> constructor has a hidden field that stores
2526 the <literal>(Eq a)</literal> dictionary that is passed to <literal>MkSet</literal>; so
2527 when pattern-matching that dictionary becomes available for the right-hand side of the match.
2528 In the example, the equality dictionary is used to satisfy the equality constraint 
2529 generated by the call to <literal>elem</literal>, so that the type of
2530 <literal>insert</literal> itself has no <literal>Eq</literal> constraint.
2531 </para>
2532 <para>
2533 For example, one possible application is to reify dictionaries:
2534 <programlisting>
2535    data NumInst a where
2536      MkNumInst :: Num a => NumInst a
2537
2538    intInst :: NumInst Int
2539    intInst = MkNumInst
2540
2541    plus :: NumInst a -> a -> a -> a
2542    plus MkNumInst p q = p + q
2543 </programlisting>
2544 Here, a value of type <literal>NumInst a</literal> is equivalent 
2545 to an explicit <literal>(Num a)</literal> dictionary.
2546 </para>
2547 <para>
2548 All this applies to constructors declared using the syntax of <xref linkend="existential-with-context"/>.
2549 For example, the <literal>NumInst</literal> data type above could equivalently be declared 
2550 like this:
2551 <programlisting>
2552    data NumInst a 
2553       = Num a => MkNumInst (NumInst a)
2554 </programlisting>
2555 Notice that, unlike the situation when declaring an existential, there is 
2556 no <literal>forall</literal>, because the <literal>Num</literal> constrains the
2557 data type's universally quantified type variable <literal>a</literal>.  
2558 A constructor may have both universal and existential type variables: for example,
2559 the following two declarations are equivalent:
2560 <programlisting>
2561    data T1 a 
2562         = forall b. (Num a, Eq b) => MkT1 a b
2563    data T2 a where
2564         MkT2 :: (Num a, Eq b) => a -> b -> T2 a
2565 </programlisting>
2566 </para>
2567 <para>All this behaviour contrasts with Haskell 98's peculiar treatment of 
2568 contexts on a data type declaration (Section 4.2.1 of the Haskell 98 Report).
2569 In Haskell 98 the definition
2570 <programlisting>
2571   data Eq a => Set' a = MkSet' [a]
2572 </programlisting>
2573 gives <literal>MkSet'</literal> the same type as <literal>MkSet</literal> above.  But instead of 
2574 <emphasis>making available</emphasis> an <literal>(Eq a)</literal> constraint, pattern-matching
2575 on <literal>MkSet'</literal> <emphasis>requires</emphasis> an <literal>(Eq a)</literal> constraint!
2576 GHC faithfully implements this behaviour, odd though it is.  But for GADT-style declarations,
2577 GHC's behaviour is much more useful, as well as much more intuitive.
2578 </para>
2579
2580 <para>
2581 The rest of this section gives further details about GADT-style data
2582 type declarations.
2583
2584 <itemizedlist>
2585 <listitem><para>
2586 The result type of each data constructor must begin with the type constructor being defined.
2587 If the result type of all constructors 
2588 has the form <literal>T a1 ... an</literal>, where <literal>a1 ... an</literal>
2589 are distinct type variables, then the data type is <emphasis>ordinary</emphasis>;
2590 otherwise is a <emphasis>generalised</emphasis> data type (<xref linkend="gadt"/>).
2591 </para></listitem>
2592
2593 <listitem><para>
2594 As with other type signatures, you can give a single signature for several data constructors.
2595 In this example we give a single signature for <literal>T1</literal> and <literal>T2</literal>:
2596 <programlisting>
2597   data T a where
2598     T1,T2 :: a -> T a
2599     T3 :: T a
2600 </programlisting>
2601 </para></listitem>
2602
2603 <listitem><para>
2604 The type signature of
2605 each constructor is independent, and is implicitly universally quantified as usual. 
2606 In particular, the type variable(s) in the "<literal>data T a where</literal>" header 
2607 have no scope, and different constructors may have different universally-quantified type variables:
2608 <programlisting>
2609   data T a where        -- The 'a' has no scope
2610     T1,T2 :: b -> T b   -- Means forall b. b -> T b
2611     T3 :: T a           -- Means forall a. T a
2612 </programlisting>
2613 </para></listitem>
2614
2615 <listitem><para>
2616 A constructor signature may mention type class constraints, which can differ for
2617 different constructors.  For example, this is fine:
2618 <programlisting>
2619   data T a where
2620     T1 :: Eq b => b -> b -> T b
2621     T2 :: (Show c, Ix c) => c -> [c] -> T c
2622 </programlisting>
2623 When patten matching, these constraints are made available to discharge constraints
2624 in the body of the match. For example:
2625 <programlisting>
2626   f :: T a -> String
2627   f (T1 x y) | x==y      = "yes"
2628              | otherwise = "no"
2629   f (T2 a b)             = show a
2630 </programlisting>
2631 Note that <literal>f</literal> is not overloaded; the <literal>Eq</literal> constraint arising
2632 from the use of <literal>==</literal> is discharged by the pattern match on <literal>T1</literal>
2633 and similarly the <literal>Show</literal> constraint arising from the use of <literal>show</literal>.
2634 </para></listitem>
2635
2636 <listitem><para>
2637 Unlike a Haskell-98-style 
2638 data type declaration, the type variable(s) in the "<literal>data Set a where</literal>" header 
2639 have no scope.  Indeed, one can write a kind signature instead:
2640 <programlisting>
2641   data Set :: * -> * where ...
2642 </programlisting>
2643 or even a mixture of the two:
2644 <programlisting>
2645   data Bar a :: (* -> *) -> * where ...
2646 </programlisting>
2647 The type variables (if given) may be explicitly kinded, so we could also write the header for <literal>Foo</literal>
2648 like this:
2649 <programlisting>
2650   data Bar a (b :: * -> *) where ...
2651 </programlisting>
2652 </para></listitem>
2653
2654
2655 <listitem><para>
2656 You can use strictness annotations, in the obvious places
2657 in the constructor type:
2658 <programlisting>
2659   data Term a where
2660       Lit    :: !Int -> Term Int
2661       If     :: Term Bool -> !(Term a) -> !(Term a) -> Term a
2662       Pair   :: Term a -> Term b -> Term (a,b)
2663 </programlisting>
2664 </para></listitem>
2665
2666 <listitem><para>
2667 You can use a <literal>deriving</literal> clause on a GADT-style data type
2668 declaration.   For example, these two declarations are equivalent
2669 <programlisting>
2670   data Maybe1 a where {
2671       Nothing1 :: Maybe1 a ;
2672       Just1    :: a -> Maybe1 a
2673     } deriving( Eq, Ord )
2674
2675   data Maybe2 a = Nothing2 | Just2 a 
2676        deriving( Eq, Ord )
2677 </programlisting>
2678 </para></listitem>
2679
2680 <listitem><para>
2681 The type signature may have quantified type variables that do not appear
2682 in the result type:
2683 <programlisting>
2684   data Foo where
2685      MkFoo :: a -> (a->Bool) -> Foo
2686      Nil   :: Foo
2687 </programlisting>
2688 Here the type variable <literal>a</literal> does not appear in the result type
2689 of either constructor.  
2690 Although it is universally quantified in the type of the constructor, such
2691 a type variable is often called "existential".  
2692 Indeed, the above declaration declares precisely the same type as 
2693 the <literal>data Foo</literal> in <xref linkend="existential-quantification"/>.
2694 </para><para>
2695 The type may contain a class context too, of course:
2696 <programlisting>
2697   data Showable where
2698     MkShowable :: Show a => a -> Showable
2699 </programlisting>
2700 </para></listitem>
2701
2702 <listitem><para>
2703 You can use record syntax on a GADT-style data type declaration:
2704
2705 <programlisting>
2706   data Person where
2707       Adult :: { name :: String, children :: [Person] } -> Person
2708       Child :: Show a => { name :: !String, funny :: a } -> Person
2709 </programlisting>
2710 As usual, for every constructor that has a field <literal>f</literal>, the type of
2711 field <literal>f</literal> must be the same (modulo alpha conversion).
2712 The <literal>Child</literal> constructor above shows that the signature
2713 may have a context, existentially-quantified variables, and strictness annotations, 
2714 just as in the non-record case.  (NB: the "type" that follows the double-colon
2715 is not really a type, because of the record syntax and strictness annotations.
2716 A "type" of this form can appear only in a constructor signature.)
2717 </para></listitem>
2718
2719 <listitem><para> 
2720 Record updates are allowed with GADT-style declarations, 
2721 only fields that have the following property: the type of the field
2722 mentions no existential type variables.
2723 </para></listitem>
2724
2725 <listitem><para> 
2726 As in the case of existentials declared using the Haskell-98-like record syntax 
2727 (<xref linkend="existential-records"/>),
2728 record-selector functions are generated only for those fields that have well-typed
2729 selectors.  
2730 Here is the example of that section, in GADT-style syntax:
2731 <programlisting>
2732 data Counter a where
2733     NewCounter { _this    :: self
2734                , _inc     :: self -> self
2735                , _display :: self -> IO ()
2736                , tag      :: a
2737                }
2738         :: Counter a
2739 </programlisting>
2740 As before, only one selector function is generated here, that for <literal>tag</literal>.
2741 Nevertheless, you can still use all the field names in pattern matching and record construction.
2742 </para></listitem>
2743 </itemizedlist></para>
2744 </sect2>
2745
2746 <sect2 id="gadt">
2747 <title>Generalised Algebraic Data Types (GADTs)</title>
2748
2749 <para>Generalised Algebraic Data Types generalise ordinary algebraic data types 
2750 by allowing constructors to have richer return types.  Here is an example:
2751 <programlisting>
2752   data Term a where
2753       Lit    :: Int -> Term Int
2754       Succ   :: Term Int -> Term Int
2755       IsZero :: Term Int -> Term Bool   
2756       If     :: Term Bool -> Term a -> Term a -> Term a
2757       Pair   :: Term a -> Term b -> Term (a,b)
2758 </programlisting>
2759 Notice that the return type of the constructors is not always <literal>Term a</literal>, as is the
2760 case with ordinary data types.  This generality allows us to 
2761 write a well-typed <literal>eval</literal> function
2762 for these <literal>Terms</literal>:
2763 <programlisting>
2764   eval :: Term a -> a
2765   eval (Lit i)      = i
2766   eval (Succ t)     = 1 + eval t
2767   eval (IsZero t)   = eval t == 0
2768   eval (If b e1 e2) = if eval b then eval e1 else eval e2
2769   eval (Pair e1 e2) = (eval e1, eval e2)
2770 </programlisting>
2771 The key point about GADTs is that <emphasis>pattern matching causes type refinement</emphasis>.  
2772 For example, in the right hand side of the equation
2773 <programlisting>
2774   eval :: Term a -> a
2775   eval (Lit i) =  ...
2776 </programlisting>
2777 the type <literal>a</literal> is refined to <literal>Int</literal>.  That's the whole point!
2778 A precise specification of the type rules is beyond what this user manual aspires to, 
2779 but the design closely follows that described in
2780 the paper <ulink
2781 url="http://research.microsoft.com/%7Esimonpj/papers/gadt/">Simple
2782 unification-based type inference for GADTs</ulink>,
2783 (ICFP 2006).
2784 The general principle is this: <emphasis>type refinement is only carried out 
2785 based on user-supplied type annotations</emphasis>.
2786 So if no type signature is supplied for <literal>eval</literal>, no type refinement happens, 
2787 and lots of obscure error messages will
2788 occur.  However, the refinement is quite general.  For example, if we had:
2789 <programlisting>
2790   eval :: Term a -> a -> a
2791   eval (Lit i) j =  i+j
2792 </programlisting>
2793 the pattern match causes the type <literal>a</literal> to be refined to <literal>Int</literal> (because of the type
2794 of the constructor <literal>Lit</literal>), and that refinement also applies to the type of <literal>j</literal>, and
2795 the result type of the <literal>case</literal> expression.  Hence the addition <literal>i+j</literal> is legal.
2796 </para>
2797 <para>
2798 These and many other examples are given in papers by Hongwei Xi, and
2799 Tim Sheard. There is a longer introduction
2800 <ulink url="http://www.haskell.org/haskellwiki/GADT">on the wiki</ulink>,
2801 and Ralf Hinze's
2802 <ulink url="http://www.informatik.uni-bonn.de/~ralf/publications/With.pdf">Fun with phantom types</ulink> also has a number of examples. Note that papers
2803 may use different notation to that implemented in GHC.
2804 </para>
2805 <para>
2806 The rest of this section outlines the extensions to GHC that support GADTs.   The extension is enabled with 
2807 <option>-XGADTs</option>.  The <option>-XGADTs</option> flag also sets <option>-XRelaxedPolyRec</option>.
2808 <itemizedlist>
2809 <listitem><para>
2810 A GADT can only be declared using GADT-style syntax (<xref linkend="gadt-style"/>); 
2811 the old Haskell-98 syntax for data declarations always declares an ordinary data type.
2812 The result type of each constructor must begin with the type constructor being defined,
2813 but for a GADT the arguments to the type constructor can be arbitrary monotypes.  
2814 For example, in the <literal>Term</literal> data
2815 type above, the type of each constructor must end with <literal>Term ty</literal>, but
2816 the <literal>ty</literal> need not be a type variable (e.g. the <literal>Lit</literal>
2817 constructor).
2818 </para></listitem>
2819
2820 <listitem><para>
2821 It is permitted to declare an ordinary algebraic data type using GADT-style syntax.
2822 What makes a GADT into a GADT is not the syntax, but rather the presence of data constructors
2823 whose result type is not just <literal>T a b</literal>.
2824 </para></listitem>
2825
2826 <listitem><para>
2827 You cannot use a <literal>deriving</literal> clause for a GADT; only for
2828 an ordinary data type.
2829 </para></listitem>
2830
2831 <listitem><para>
2832 As mentioned in <xref linkend="gadt-style"/>, record syntax is supported.
2833 For example:
2834 <programlisting>
2835   data Term a where
2836       Lit    { val  :: Int }      :: Term Int
2837       Succ   { num  :: Term Int } :: Term Int
2838       Pred   { num  :: Term Int } :: Term Int
2839       IsZero { arg  :: Term Int } :: Term Bool  
2840       Pair   { arg1 :: Term a
2841              , arg2 :: Term b
2842              }                    :: Term (a,b)
2843       If     { cnd  :: Term Bool
2844              , tru  :: Term a
2845              , fls  :: Term a
2846              }                    :: Term a
2847 </programlisting>
2848 However, for GADTs there is the following additional constraint: 
2849 every constructor that has a field <literal>f</literal> must have
2850 the same result type (modulo alpha conversion)
2851 Hence, in the above example, we cannot merge the <literal>num</literal> 
2852 and <literal>arg</literal> fields above into a 
2853 single name.  Although their field types are both <literal>Term Int</literal>,
2854 their selector functions actually have different types:
2855
2856 <programlisting>
2857   num :: Term Int -> Term Int
2858   arg :: Term Bool -> Term Int
2859 </programlisting>
2860 </para></listitem>
2861
2862 <listitem><para>
2863 When pattern-matching against data constructors drawn from a GADT, 
2864 for example in a <literal>case</literal> expression, the following rules apply:
2865 <itemizedlist>
2866 <listitem><para>The type of the scrutinee must be rigid.</para></listitem>
2867 <listitem><para>The type of the entire <literal>case</literal> expression must be rigid.</para></listitem>
2868 <listitem><para>The type of any free variable mentioned in any of
2869 the <literal>case</literal> alternatives must be rigid.</para></listitem>
2870 </itemizedlist>
2871 A type is "rigid" if it is completely known to the compiler at its binding site.  The easiest
2872 way to ensure that a variable a rigid type is to give it a type signature.
2873 For more precise details see <ulink url="http://research.microsoft.com/%7Esimonpj/papers/gadt">
2874 Simple unification-based type inference for GADTs
2875 </ulink>. The criteria implemented by GHC are given in the Appendix.
2876
2877 </para></listitem>
2878
2879 </itemizedlist>
2880 </para>
2881
2882 </sect2>
2883 </sect1>
2884
2885 <!-- ====================== End of Generalised algebraic data types =======================  -->
2886
2887 <sect1 id="deriving">
2888 <title>Extensions to the "deriving" mechanism</title>
2889
2890 <sect2 id="deriving-inferred">
2891 <title>Inferred context for deriving clauses</title>
2892
2893 <para>
2894 The Haskell Report is vague about exactly when a <literal>deriving</literal> clause is
2895 legal.  For example:
2896 <programlisting>
2897   data T0 f a = MkT0 a         deriving( Eq )
2898   data T1 f a = MkT1 (f a)     deriving( Eq )
2899   data T2 f a = MkT2 (f (f a)) deriving( Eq )
2900 </programlisting>
2901 The natural generated <literal>Eq</literal> code would result in these instance declarations:
2902 <programlisting>
2903   instance Eq a         => Eq (T0 f a) where ...
2904   instance Eq (f a)     => Eq (T1 f a) where ...
2905   instance Eq (f (f a)) => Eq (T2 f a) where ...
2906 </programlisting>
2907 The first of these is obviously fine. The second is still fine, although less obviously. 
2908 The third is not Haskell 98, and risks losing termination of instances.
2909 </para>
2910 <para>
2911 GHC takes a conservative position: it accepts the first two, but not the third.  The  rule is this:
2912 each constraint in the inferred instance context must consist only of type variables, 
2913 with no repetitions.
2914 </para>
2915 <para>
2916 This rule is applied regardless of flags.  If you want a more exotic context, you can write
2917 it yourself, using the <link linkend="stand-alone-deriving">standalone deriving mechanism</link>.
2918 </para>
2919 </sect2>
2920
2921 <sect2 id="stand-alone-deriving">
2922 <title>Stand-alone deriving declarations</title>
2923
2924 <para>
2925 GHC now allows stand-alone <literal>deriving</literal> declarations, enabled by <literal>-XStandaloneDeriving</literal>:
2926 <programlisting>
2927   data Foo a = Bar a | Baz String
2928
2929   deriving instance Eq a => Eq (Foo a)
2930 </programlisting>
2931 The syntax is identical to that of an ordinary instance declaration apart from (a) the keyword
2932 <literal>deriving</literal>, and (b) the absence of the <literal>where</literal> part.
2933 Note the following points:
2934 <itemizedlist>
2935 <listitem><para>
2936 You must supply an explicit context (in the example the context is <literal>(Eq a)</literal>), 
2937 exactly as you would in an ordinary instance declaration.
2938 (In contrast, in a <literal>deriving</literal> clause 
2939 attached to a data type declaration, the context is inferred.) 
2940 </para></listitem>
2941
2942 <listitem><para>
2943 A <literal>deriving instance</literal> declaration
2944 must obey the same rules concerning form and termination as ordinary instance declarations,
2945 controlled by the same flags; see <xref linkend="instance-decls"/>.
2946 </para></listitem>
2947
2948 <listitem><para>
2949 Unlike a <literal>deriving</literal>
2950 declaration attached to a <literal>data</literal> declaration, the instance can be more specific
2951 than the data type (assuming you also use 
2952 <literal>-XFlexibleInstances</literal>, <xref linkend="instance-rules"/>).  Consider
2953 for example
2954 <programlisting>
2955   data Foo a = Bar a | Baz String
2956
2957   deriving instance Eq a => Eq (Foo [a])
2958   deriving instance Eq a => Eq (Foo (Maybe a))
2959 </programlisting>
2960 This will generate a derived instance for <literal>(Foo [a])</literal> and <literal>(Foo (Maybe a))</literal>,
2961 but other types such as <literal>(Foo (Int,Bool))</literal> will not be an instance of <literal>Eq</literal>.
2962 </para></listitem>
2963
2964 <listitem><para>
2965 Unlike a <literal>deriving</literal>
2966 declaration attached to a <literal>data</literal> declaration, 
2967 GHC does not restrict the form of the data type.  Instead, GHC simply generates the appropriate
2968 boilerplate code for the specified class, and typechecks it. If there is a type error, it is
2969 your problem. (GHC will show you the offending code if it has a type error.) 
2970 The merit of this is that you can derive instances for GADTs and other exotic
2971 data types, providing only that the boilerplate code does indeed typecheck.  For example:
2972 <programlisting>
2973   data T a where
2974      T1 :: T Int
2975      T2 :: T Bool
2976
2977   deriving instance Show (T a)
2978 </programlisting>
2979 In this example, you cannot say <literal>... deriving( Show )</literal> on the 
2980 data type declaration for <literal>T</literal>, 
2981 because <literal>T</literal> is a GADT, but you <emphasis>can</emphasis> generate
2982 the instance declaration using stand-alone deriving.
2983 </para>
2984 </listitem>
2985
2986 <listitem>
2987 <para>The stand-alone syntax is generalised for newtypes in exactly the same
2988 way that ordinary <literal>deriving</literal> clauses are generalised (<xref linkend="newtype-deriving"/>).
2989 For example:
2990 <programlisting>
2991   newtype Foo a = MkFoo (State Int a)
2992
2993   deriving instance MonadState Int Foo
2994 </programlisting>
2995 GHC always treats the <emphasis>last</emphasis> parameter of the instance
2996 (<literal>Foo</literal> in this example) as the type whose instance is being derived.
2997 </para></listitem>
2998 </itemizedlist></para>
2999
3000 </sect2>
3001
3002
3003 <sect2 id="deriving-typeable">
3004 <title>Deriving clause for extra classes (<literal>Typeable</literal>, <literal>Data</literal>, etc)</title>
3005
3006 <para>
3007 Haskell 98 allows the programmer to add "<literal>deriving( Eq, Ord )</literal>" to a data type 
3008 declaration, to generate a standard instance declaration for classes specified in the <literal>deriving</literal> clause.  
3009 In Haskell 98, the only classes that may appear in the <literal>deriving</literal> clause are the standard
3010 classes <literal>Eq</literal>, <literal>Ord</literal>, 
3011 <literal>Enum</literal>, <literal>Ix</literal>, <literal>Bounded</literal>, <literal>Read</literal>, and <literal>Show</literal>.
3012 </para>
3013 <para>
3014 GHC extends this list with several more classes that may be automatically derived:
3015 <itemizedlist>
3016 <listitem><para> With <option>-XDeriveDataTypeable</option>, you can derive instances of the classes
3017 <literal>Typeable</literal>, and <literal>Data</literal>, defined in the library
3018 modules <literal>Data.Typeable</literal> and <literal>Data.Generics</literal> respectively.
3019 </para>
3020 <para>An instance of <literal>Typeable</literal> can only be derived if the
3021 data type has seven or fewer type parameters, all of kind <literal>*</literal>.
3022 The reason for this is that the <literal>Typeable</literal> class is derived using the scheme
3023 described in
3024 <ulink url="http://research.microsoft.com/%7Esimonpj/papers/hmap/gmap2.ps">
3025 Scrap More Boilerplate: Reflection, Zips, and Generalised Casts
3026 </ulink>.
3027 (Section 7.4 of the paper describes the multiple <literal>Typeable</literal> classes that
3028 are used, and only <literal>Typeable1</literal> up to
3029 <literal>Typeable7</literal> are provided in the library.)
3030 In other cases, there is nothing to stop the programmer writing a <literal>TypableX</literal>
3031 class, whose kind suits that of the data type constructor, and
3032 then writing the data type instance by hand.
3033 </para>
3034 </listitem>
3035
3036 <listitem><para> With <option>-XDeriveFunctor</option>, you can derive instances of 
3037 the class <literal>Functor</literal>,
3038 defined in <literal>GHC.Base</literal>.
3039 </para></listitem>
3040
3041 <listitem><para> With <option>-XDeriveFoldable</option>, you can derive instances of 
3042 the class <literal>Foldable</literal>,
3043 defined in <literal>Data.Foldable</literal>.
3044 </para></listitem>
3045
3046 <listitem><para> With <option>-XDeriveTraversable</option>, you can derive instances of 
3047 the class <literal>Traversable</literal>,
3048 defined in <literal>Data.Traversable</literal>.
3049 </para></listitem>
3050 </itemizedlist>
3051 In each case the appropriate class must be in scope before it 
3052 can be mentioned in the <literal>deriving</literal> clause.
3053 </para>
3054 </sect2>
3055
3056 <sect2 id="newtype-deriving">
3057 <title>Generalised derived instances for newtypes</title>
3058
3059 <para>
3060 When you define an abstract type using <literal>newtype</literal>, you may want
3061 the new type to inherit some instances from its representation. In
3062 Haskell 98, you can inherit instances of <literal>Eq</literal>, <literal>Ord</literal>,
3063 <literal>Enum</literal> and <literal>Bounded</literal> by deriving them, but for any
3064 other classes you have to write an explicit instance declaration. For
3065 example, if you define
3066
3067 <programlisting>
3068   newtype Dollars = Dollars Int 
3069 </programlisting>
3070
3071 and you want to use arithmetic on <literal>Dollars</literal>, you have to
3072 explicitly define an instance of <literal>Num</literal>:
3073
3074 <programlisting>
3075   instance Num Dollars where
3076     Dollars a + Dollars b = Dollars (a+b)
3077     ...
3078 </programlisting>
3079 All the instance does is apply and remove the <literal>newtype</literal>
3080 constructor. It is particularly galling that, since the constructor
3081 doesn't appear at run-time, this instance declaration defines a
3082 dictionary which is <emphasis>wholly equivalent</emphasis> to the <literal>Int</literal>
3083 dictionary, only slower!
3084 </para>
3085
3086
3087 <sect3> <title> Generalising the deriving clause </title>
3088 <para>
3089 GHC now permits such instances to be derived instead, 
3090 using the flag <option>-XGeneralizedNewtypeDeriving</option>,
3091 so one can write 
3092 <programlisting>
3093   newtype Dollars = Dollars Int deriving (Eq,Show,Num)
3094 </programlisting>
3095
3096 and the implementation uses the <emphasis>same</emphasis> <literal>Num</literal> dictionary
3097 for <literal>Dollars</literal> as for <literal>Int</literal>. Notionally, the compiler
3098 derives an instance declaration of the form
3099
3100 <programlisting>
3101   instance Num Int => Num Dollars
3102 </programlisting>
3103
3104 which just adds or removes the <literal>newtype</literal> constructor according to the type.
3105 </para>
3106 <para>
3107
3108 We can also derive instances of constructor classes in a similar
3109 way. For example, suppose we have implemented state and failure monad
3110 transformers, such that
3111
3112 <programlisting>
3113   instance Monad m => Monad (State s m) 
3114   instance Monad m => Monad (Failure m)
3115 </programlisting>
3116 In Haskell 98, we can define a parsing monad by 
3117 <programlisting>
3118   type Parser tok m a = State [tok] (Failure m) a
3119 </programlisting>
3120
3121 which is automatically a monad thanks to the instance declarations
3122 above. With the extension, we can make the parser type abstract,
3123 without needing to write an instance of class <literal>Monad</literal>, via
3124
3125 <programlisting>
3126   newtype Parser tok m a = Parser (State [tok] (Failure m) a)
3127                          deriving Monad
3128 </programlisting>
3129 In this case the derived instance declaration is of the form 
3130 <programlisting>
3131   instance Monad (State [tok] (Failure m)) => Monad (Parser tok m) 
3132 </programlisting>
3133
3134 Notice that, since <literal>Monad</literal> is a constructor class, the
3135 instance is a <emphasis>partial application</emphasis> of the new type, not the
3136 entire left hand side. We can imagine that the type declaration is
3137 "eta-converted" to generate the context of the instance
3138 declaration.
3139 </para>
3140 <para>
3141
3142 We can even derive instances of multi-parameter classes, provided the
3143 newtype is the last class parameter. In this case, a ``partial
3144 application'' of the class appears in the <literal>deriving</literal>
3145 clause. For example, given the class
3146
3147 <programlisting>
3148   class StateMonad s m | m -> s where ... 
3149   instance Monad m => StateMonad s (State s m) where ... 
3150 </programlisting>
3151 then we can derive an instance of <literal>StateMonad</literal> for <literal>Parser</literal>s by 
3152 <programlisting>
3153   newtype Parser tok m a = Parser (State [tok] (Failure m) a)
3154                          deriving (Monad, StateMonad [tok])
3155 </programlisting>
3156
3157 The derived instance is obtained by completing the application of the
3158 class to the new type:
3159
3160 <programlisting>
3161   instance StateMonad [tok] (State [tok] (Failure m)) =>
3162            StateMonad [tok] (Parser tok m)
3163 </programlisting>
3164 </para>
3165 <para>
3166
3167 As a result of this extension, all derived instances in newtype
3168  declarations are treated uniformly (and implemented just by reusing
3169 the dictionary for the representation type), <emphasis>except</emphasis>
3170 <literal>Show</literal> and <literal>Read</literal>, which really behave differently for
3171 the newtype and its representation.
3172 </para>
3173 </sect3>
3174
3175 <sect3> <title> A more precise specification </title>
3176 <para>
3177 Derived instance declarations are constructed as follows. Consider the
3178 declaration (after expansion of any type synonyms)
3179
3180 <programlisting>
3181   newtype T v1...vn = T' (t vk+1...vn) deriving (c1...cm) 
3182 </programlisting>
3183
3184 where 
3185  <itemizedlist>
3186 <listitem><para>
3187   The <literal>ci</literal> are partial applications of
3188   classes of the form <literal>C t1'...tj'</literal>, where the arity of <literal>C</literal>
3189   is exactly <literal>j+1</literal>.  That is, <literal>C</literal> lacks exactly one type argument.
3190 </para></listitem>
3191 <listitem><para>
3192   The <literal>k</literal> is chosen so that <literal>ci (T v1...vk)</literal> is well-kinded.
3193 </para></listitem>
3194 <listitem><para>
3195   The type <literal>t</literal> is an arbitrary type.
3196 </para></listitem>
3197 <listitem><para>
3198   The type variables <literal>vk+1...vn</literal> do not occur in <literal>t</literal>, 
3199   nor in the <literal>ci</literal>, and
3200 </para></listitem>
3201 <listitem><para>
3202   None of the <literal>ci</literal> is <literal>Read</literal>, <literal>Show</literal>, 
3203                 <literal>Typeable</literal>, or <literal>Data</literal>.  These classes
3204                 should not "look through" the type or its constructor.  You can still
3205                 derive these classes for a newtype, but it happens in the usual way, not 
3206                 via this new mechanism.  
3207 </para></listitem>
3208 </itemizedlist>
3209 Then, for each <literal>ci</literal>, the derived instance
3210 declaration is:
3211 <programlisting>
3212   instance ci t => ci (T v1...vk)
3213 </programlisting>
3214 As an example which does <emphasis>not</emphasis> work, consider 
3215 <programlisting>
3216   newtype NonMonad m s = NonMonad (State s m s) deriving Monad 
3217 </programlisting>
3218 Here we cannot derive the instance 
3219 <programlisting>
3220   instance Monad (State s m) => Monad (NonMonad m) 
3221 </programlisting>
3222
3223 because the type variable <literal>s</literal> occurs in <literal>State s m</literal>,
3224 and so cannot be "eta-converted" away. It is a good thing that this
3225 <literal>deriving</literal> clause is rejected, because <literal>NonMonad m</literal> is
3226 not, in fact, a monad --- for the same reason. Try defining
3227 <literal>>>=</literal> with the correct type: you won't be able to.
3228 </para>
3229 <para>
3230
3231 Notice also that the <emphasis>order</emphasis> of class parameters becomes
3232 important, since we can only derive instances for the last one. If the
3233 <literal>StateMonad</literal> class above were instead defined as
3234
3235 <programlisting>
3236   class StateMonad m s | m -> s where ... 
3237 </programlisting>
3238
3239 then we would not have been able to derive an instance for the
3240 <literal>Parser</literal> type above. We hypothesise that multi-parameter
3241 classes usually have one "main" parameter for which deriving new
3242 instances is most interesting.
3243 </para>
3244 <para>Lastly, all of this applies only for classes other than
3245 <literal>Read</literal>, <literal>Show</literal>, <literal>Typeable</literal>, 
3246 and <literal>Data</literal>, for which the built-in derivation applies (section
3247 4.3.3. of the Haskell Report).
3248 (For the standard classes <literal>Eq</literal>, <literal>Ord</literal>,
3249 <literal>Ix</literal>, and <literal>Bounded</literal> it is immaterial whether
3250 the standard method is used or the one described here.)
3251 </para>
3252 </sect3>
3253 </sect2>
3254 </sect1>
3255
3256
3257 <!-- TYPE SYSTEM EXTENSIONS -->
3258 <sect1 id="type-class-extensions">
3259 <title>Class and instances declarations</title>
3260
3261 <sect2 id="multi-param-type-classes">
3262 <title>Class declarations</title>
3263
3264 <para>
3265 This section, and the next one, documents GHC's type-class extensions.
3266 There's lots of background in the paper <ulink
3267 url="http://research.microsoft.com/~simonpj/Papers/type-class-design-space/">Type
3268 classes: exploring the design space</ulink> (Simon Peyton Jones, Mark
3269 Jones, Erik Meijer).
3270 </para>
3271 <para>
3272 All the extensions are enabled by the <option>-fglasgow-exts</option> flag.
3273 </para>
3274
3275 <sect3>
3276 <title>Multi-parameter type classes</title>
3277 <para>
3278 Multi-parameter type classes are permitted, with flag <option>-XMultiParamTypeClasses</option>. 
3279 For example:
3280
3281
3282 <programlisting>
3283   class Collection c a where
3284     union :: c a -> c a -> c a
3285     ...etc.
3286 </programlisting>
3287
3288 </para>
3289 </sect3>
3290
3291 <sect3 id="superclass-rules">
3292 <title>The superclasses of a class declaration</title>
3293
3294 <para>
3295 In Haskell 98 the context of a class declaration (which introduces superclasses)
3296 must be simple; that is, each predicate must consist of a class applied to 
3297 type variables.  The flag <option>-XFlexibleContexts</option> 
3298 (<xref linkend="flexible-contexts"/>)
3299 lifts this restriction,
3300 so that the only restriction on the context in a class declaration is 
3301 that the class hierarchy must be acyclic.  So these class declarations are OK:
3302
3303
3304 <programlisting>
3305   class Functor (m k) => FiniteMap m k where
3306     ...
3307
3308   class (Monad m, Monad (t m)) => Transform t m where
3309     lift :: m a -> (t m) a
3310 </programlisting>
3311
3312
3313 </para>
3314 <para>
3315 As in Haskell 98, The class hierarchy must be acyclic.  However, the definition
3316 of "acyclic" involves only the superclass relationships.  For example,
3317 this is OK:
3318
3319
3320 <programlisting>
3321   class C a where {
3322     op :: D b => a -> b -> b
3323   }
3324
3325   class C a => D a where { ... }
3326 </programlisting>
3327
3328
3329 Here, <literal>C</literal> is a superclass of <literal>D</literal>, but it's OK for a
3330 class operation <literal>op</literal> of <literal>C</literal> to mention <literal>D</literal>.  (It
3331 would not be OK for <literal>D</literal> to be a superclass of <literal>C</literal>.)
3332 </para>
3333 </sect3>
3334
3335
3336
3337
3338 <sect3 id="class-method-types">
3339 <title>Class method types</title>
3340
3341 <para>
3342 Haskell 98 prohibits class method types to mention constraints on the
3343 class type variable, thus:
3344 <programlisting>
3345   class Seq s a where
3346     fromList :: [a] -> s a
3347     elem     :: Eq a => a -> s a -> Bool
3348 </programlisting>
3349 The type of <literal>elem</literal> is illegal in Haskell 98, because it
3350 contains the constraint <literal>Eq a</literal>, constrains only the 
3351 class type variable (in this case <literal>a</literal>).
3352 GHC lifts this restriction (flag <option>-XConstrainedClassMethods</option>).
3353 </para>
3354
3355
3356 </sect3>
3357 </sect2>
3358
3359 <sect2 id="functional-dependencies">
3360 <title>Functional dependencies
3361 </title>
3362
3363 <para> Functional dependencies are implemented as described by Mark Jones
3364 in &ldquo;<ulink url="http://citeseer.ist.psu.edu/jones00type.html">Type Classes with Functional Dependencies</ulink>&rdquo;, Mark P. Jones, 
3365 In Proceedings of the 9th European Symposium on Programming, 
3366 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782,
3367 .
3368 </para>
3369 <para>
3370 Functional dependencies are introduced by a vertical bar in the syntax of a 
3371 class declaration;  e.g. 
3372 <programlisting>
3373   class (Monad m) => MonadState s m | m -> s where ...
3374
3375   class Foo a b c | a b -> c where ...
3376 </programlisting>
3377 There should be more documentation, but there isn't (yet).  Yell if you need it.
3378 </para>
3379
3380 <sect3><title>Rules for functional dependencies </title>
3381 <para>
3382 In a class declaration, all of the class type variables must be reachable (in the sense 
3383 mentioned in <xref linkend="flexible-contexts"/>)
3384 from the free variables of each method type.
3385 For example:
3386
3387 <programlisting>
3388   class Coll s a where
3389     empty  :: s
3390     insert :: s -> a -> s
3391 </programlisting>
3392
3393 is not OK, because the type of <literal>empty</literal> doesn't mention
3394 <literal>a</literal>.  Functional dependencies can make the type variable
3395 reachable:
3396 <programlisting>
3397   class Coll s a | s -> a where
3398     empty  :: s
3399     insert :: s -> a -> s
3400 </programlisting>
3401
3402 Alternatively <literal>Coll</literal> might be rewritten
3403
3404 <programlisting>
3405   class Coll s a where
3406     empty  :: s a
3407     insert :: s a -> a -> s a
3408 </programlisting>
3409
3410
3411 which makes the connection between the type of a collection of
3412 <literal>a</literal>'s (namely <literal>(s a)</literal>) and the element type <literal>a</literal>.
3413 Occasionally this really doesn't work, in which case you can split the
3414 class like this:
3415
3416
3417 <programlisting>
3418   class CollE s where
3419     empty  :: s
3420
3421   class CollE s => Coll s a where
3422     insert :: s -> a -> s
3423 </programlisting>
3424 </para>
3425 </sect3>
3426
3427
3428 <sect3>
3429 <title>Background on functional dependencies</title>
3430
3431 <para>The following description of the motivation and use of functional dependencies is taken
3432 from the Hugs user manual, reproduced here (with minor changes) by kind
3433 permission of Mark Jones.
3434 </para>
3435 <para> 
3436 Consider the following class, intended as part of a
3437 library for collection types:
3438 <programlisting>
3439    class Collects e ce where
3440        empty  :: ce
3441        insert :: e -> ce -> ce
3442        member :: e -> ce -> Bool
3443 </programlisting>
3444 The type variable e used here represents the element type, while ce is the type
3445 of the container itself. Within this framework, we might want to define
3446 instances of this class for lists or characteristic functions (both of which
3447 can be used to represent collections of any equality type), bit sets (which can
3448 be used to represent collections of characters), or hash tables (which can be
3449 used to represent any collection whose elements have a hash function). Omitting
3450 standard implementation details, this would lead to the following declarations: 
3451 <programlisting>
3452    instance Eq e => Collects e [e] where ...
3453    instance Eq e => Collects e (e -> Bool) where ...
3454    instance Collects Char BitSet where ...
3455    instance (Hashable e, Collects a ce)
3456               => Collects e (Array Int ce) where ...
3457 </programlisting>
3458 All this looks quite promising; we have a class and a range of interesting
3459 implementations. Unfortunately, there are some serious problems with the class
3460 declaration. First, the empty function has an ambiguous type: 
3461 <programlisting>
3462    empty :: Collects e ce => ce
3463 </programlisting>
3464 By "ambiguous" we mean that there is a type variable e that appears on the left
3465 of the <literal>=&gt;</literal> symbol, but not on the right. The problem with
3466 this is that, according to the theoretical foundations of Haskell overloading,
3467 we cannot guarantee a well-defined semantics for any term with an ambiguous
3468 type.
3469 </para>
3470 <para>
3471 We can sidestep this specific problem by removing the empty member from the
3472 class declaration. However, although the remaining members, insert and member,
3473 do not have ambiguous types, we still run into problems when we try to use
3474 them. For example, consider the following two functions: 
3475 <programlisting>
3476    f x y = insert x . insert y
3477    g     = f True 'a'
3478 </programlisting>
3479 for which GHC infers the following types: 
3480 <programlisting>
3481    f :: (Collects a c, Collects b c) => a -> b -> c -> c
3482    g :: (Collects Bool c, Collects Char c) => c -> c
3483 </programlisting>
3484 Notice that the type for f allows the two parameters x and y to be assigned
3485 different types, even though it attempts to insert each of the two values, one
3486 after the other, into the same collection. If we're trying to model collections
3487 that contain only one type of value, then this is clearly an inaccurate
3488 type. Worse still, the definition for g is accepted, without causing a type
3489 error. As a result, the error in this code will not be flagged at the point
3490 where it appears. Instead, it will show up only when we try to use g, which
3491 might even be in a different module.
3492 </para>
3493
3494 <sect4><title>An attempt to use constructor classes</title>
3495
3496 <para>
3497 Faced with the problems described above, some Haskell programmers might be
3498 tempted to use something like the following version of the class declaration: 
3499 <programlisting>
3500    class Collects e c where
3501       empty  :: c e
3502       insert :: e -> c e -> c e
3503       member :: e -> c e -> Bool
3504 </programlisting>
3505 The key difference here is that we abstract over the type constructor c that is
3506 used to form the collection type c e, and not over that collection type itself,
3507 represented by ce in the original class declaration. This avoids the immediate
3508 problems that we mentioned above: empty has type <literal>Collects e c => c
3509 e</literal>, which is not ambiguous. 
3510 </para>
3511 <para>
3512 The function f from the previous section has a more accurate type: 
3513 <programlisting>
3514    f :: (Collects e c) => e -> e -> c e -> c e
3515 </programlisting>
3516 The function g from the previous section is now rejected with a type error as
3517 we would hope because the type of f does not allow the two arguments to have
3518 different types. 
3519 This, then, is an example of a multiple parameter class that does actually work
3520 quite well in practice, without ambiguity problems.
3521 There is, however, a catch. This version of the Collects class is nowhere near
3522 as general as the original class seemed to be: only one of the four instances
3523 for <literal>Collects</literal>
3524 given above can be used with this version of Collects because only one of
3525 them---the instance for lists---has a collection type that can be written in
3526 the form c e, for some type constructor c, and element type e.
3527 </para>
3528 </sect4>
3529
3530 <sect4><title>Adding functional dependencies</title>
3531
3532 <para>
3533 To get a more useful version of the Collects class, Hugs provides a mechanism
3534 that allows programmers to specify dependencies between the parameters of a
3535 multiple parameter class (For readers with an interest in theoretical
3536 foundations and previous work: The use of dependency information can be seen
3537 both as a generalization of the proposal for `parametric type classes' that was
3538 put forward by Chen, Hudak, and Odersky, or as a special case of Mark Jones's
3539 later framework for "improvement" of qualified types. The
3540 underlying ideas are also discussed in a more theoretical and abstract setting
3541 in a manuscript [implparam], where they are identified as one point in a
3542 general design space for systems of implicit parameterization.).
3543
3544 To start with an abstract example, consider a declaration such as: 
3545 <programlisting>
3546    class C a b where ...
3547 </programlisting>
3548 which tells us simply that C can be thought of as a binary relation on types
3549 (or type constructors, depending on the kinds of a and b). Extra clauses can be
3550 included in the definition of classes to add information about dependencies
3551 between parameters, as in the following examples: 
3552 <programlisting>
3553    class D a b | a -> b where ...
3554    class E a b | a -> b, b -> a where ...
3555 </programlisting>
3556 The notation <literal>a -&gt; b</literal> used here between the | and where
3557 symbols --- not to be
3558 confused with a function type --- indicates that the a parameter uniquely
3559 determines the b parameter, and might be read as "a determines b." Thus D is
3560 not just a relation, but actually a (partial) function. Similarly, from the two
3561 dependencies that are included in the definition of E, we can see that E
3562 represents a (partial) one-one mapping between types.
3563 </para>
3564 <para>
3565 More generally, dependencies take the form <literal>x1 ... xn -&gt; y1 ... ym</literal>,
3566 where x1, ..., xn, and y1, ..., yn are type variables with n&gt;0 and
3567 m&gt;=0, meaning that the y parameters are uniquely determined by the x
3568 parameters. Spaces can be used as separators if more than one variable appears
3569 on any single side of a dependency, as in <literal>t -&gt; a b</literal>. Note that a class may be
3570 annotated with multiple dependencies using commas as separators, as in the
3571 definition of E above. Some dependencies that we can write in this notation are
3572 redundant, and will be rejected because they don't serve any useful
3573 purpose, and may instead indicate an error in the program. Examples of
3574 dependencies like this include  <literal>a -&gt; a </literal>,  
3575 <literal>a -&gt; a a </literal>,  
3576 <literal>a -&gt; </literal>, etc. There can also be
3577 some redundancy if multiple dependencies are given, as in  
3578 <literal>a-&gt;b</literal>, 
3579  <literal>b-&gt;c </literal>,  <literal>a-&gt;c </literal>, and
3580 in which some subset implies the remaining dependencies. Examples like this are
3581 not treated as errors. Note that dependencies appear only in class
3582 declarations, and not in any other part of the language. In particular, the
3583 syntax for instance declarations, class constraints, and types is completely
3584 unchanged.
3585 </para>
3586 <para>
3587 By including dependencies in a class declaration, we provide a mechanism for
3588 the programmer to specify each multiple parameter class more precisely. The
3589 compiler, on the other hand, is responsible for ensuring that the set of
3590 instances that are in scope at any given point in the program is consistent
3591 with any declared dependencies. For example, the following pair of instance
3592 declarations cannot appear together in the same scope because they violate the
3593 dependency for D, even though either one on its own would be acceptable: 
3594 <programlisting>
3595    instance D Bool Int where ...
3596    instance D Bool Char where ...
3597 </programlisting>
3598 Note also that the following declaration is not allowed, even by itself: 
3599 <programlisting>
3600    instance D [a] b where ...
3601 </programlisting>
3602 The problem here is that this instance would allow one particular choice of [a]
3603 to be associated with more than one choice for b, which contradicts the
3604 dependency specified in the definition of D. More generally, this means that,
3605 in any instance of the form: 
3606 <programlisting>
3607    instance D t s where ...
3608 </programlisting>
3609 for some particular types t and s, the only variables that can appear in s are
3610 the ones that appear in t, and hence, if the type t is known, then s will be
3611 uniquely determined.
3612 </para>
3613 <para>
3614 The benefit of including dependency information is that it allows us to define
3615 more general multiple parameter classes, without ambiguity problems, and with
3616 the benefit of more accurate types. To illustrate this, we return to the
3617 collection class example, and annotate the original definition of <literal>Collects</literal>
3618 with a simple dependency: 
3619 <programlisting>
3620    class Collects e ce | ce -> e where
3621       empty  :: ce
3622       insert :: e -> ce -> ce
3623       member :: e -> ce -> Bool
3624 </programlisting>
3625 The dependency <literal>ce -&gt; e</literal> here specifies that the type e of elements is uniquely
3626 determined by the type of the collection ce. Note that both parameters of
3627 Collects are of kind *; there are no constructor classes here. Note too that
3628 all of the instances of Collects that we gave earlier can be used
3629 together with this new definition.
3630 </para>
3631 <para>
3632 What about the ambiguity problems that we encountered with the original
3633 definition? The empty function still has type Collects e ce => ce, but it is no
3634 longer necessary to regard that as an ambiguous type: Although the variable e
3635 does not appear on the right of the => symbol, the dependency for class
3636 Collects tells us that it is uniquely determined by ce, which does appear on
3637 the right of the => symbol. Hence the context in which empty is used can still
3638 give enough information to determine types for both ce and e, without
3639 ambiguity. More generally, we need only regard a type as ambiguous if it
3640 contains a variable on the left of the => that is not uniquely determined
3641 (either directly or indirectly) by the variables on the right.
3642 </para>
3643 <para>
3644 Dependencies also help to produce more accurate types for user defined
3645 functions, and hence to provide earlier detection of errors, and less cluttered
3646 types for programmers to work with. Recall the previous definition for a
3647 function f: 
3648 <programlisting>
3649    f x y = insert x y = insert x . insert y
3650 </programlisting>
3651 for which we originally obtained a type: 
3652 <programlisting>
3653    f :: (Collects a c, Collects b c) => a -> b -> c -> c
3654 </programlisting>
3655 Given the dependency information that we have for Collects, however, we can
3656 deduce that a and b must be equal because they both appear as the second
3657 parameter in a Collects constraint with the same first parameter c. Hence we
3658 can infer a shorter and more accurate type for f: 
3659 <programlisting>
3660    f :: (Collects a c) => a -> a -> c -> c
3661 </programlisting>
3662 In a similar way, the earlier definition of g will now be flagged as a type error.
3663 </para>
3664 <para>
3665 Although we have given only a few examples here, it should be clear that the
3666 addition of dependency information can help to make multiple parameter classes
3667 more useful in practice, avoiding ambiguity problems, and allowing more general
3668 sets of instance declarations.
3669 </para>
3670 </sect4>
3671 </sect3>
3672 </sect2>
3673
3674 <sect2 id="instance-decls">
3675 <title>Instance declarations</title>
3676
3677 <para>An instance declaration has the form
3678 <screen>
3679   instance ( <replaceable>assertion</replaceable><subscript>1</subscript>, ..., <replaceable>assertion</replaceable><subscript>n</subscript>) =&gt; <replaceable>class</replaceable> <replaceable>type</replaceable><subscript>1</subscript> ... <replaceable>type</replaceable><subscript>m</subscript> where ...
3680 </screen>
3681 The part before the "<literal>=&gt;</literal>" is the
3682 <emphasis>context</emphasis>, while the part after the
3683 "<literal>=&gt;</literal>" is the <emphasis>head</emphasis> of the instance declaration.
3684 </para>
3685
3686 <sect3 id="flexible-instance-head">
3687 <title>Relaxed rules for the instance head</title>
3688
3689 <para>
3690 In Haskell 98 the head of an instance declaration
3691 must be of the form <literal>C (T a1 ... an)</literal>, where
3692 <literal>C</literal> is the class, <literal>T</literal> is a data type constructor,
3693 and the <literal>a1 ... an</literal> are distinct type variables.
3694 GHC relaxes these rules in two ways.
3695 <itemizedlist>
3696 <listitem>
3697 <para>
3698 The <option>-XFlexibleInstances</option> flag allows the head of the instance
3699 declaration to mention arbitrary nested types.
3700 For example, this becomes a legal instance declaration
3701 <programlisting>
3702   instance C (Maybe Int) where ...
3703 </programlisting>
3704 See also the <link linkend="instance-overlap">rules on overlap</link>.
3705 </para></listitem>
3706 <listitem><para>
3707 With the <option>-XTypeSynonymInstances</option> flag, instance heads may use type
3708 synonyms. As always, using a type synonym is just shorthand for
3709 writing the RHS of the type synonym definition.  For example:
3710
3711
3712 <programlisting>
3713   type Point = (Int,Int)
3714   instance C Point   where ...
3715   instance C [Point] where ...
3716 </programlisting>
3717
3718
3719 is legal.  However, if you added
3720
3721
3722 <programlisting>
3723   instance C (Int,Int) where ...
3724 </programlisting>
3725
3726
3727 as well, then the compiler will complain about the overlapping
3728 (actually, identical) instance declarations.  As always, type synonyms
3729 must be fully applied.  You cannot, for example, write:
3730
3731 <programlisting>
3732   type P a = [[a]]
3733   instance Monad P where ...
3734 </programlisting>
3735
3736 </para></listitem>
3737 </itemizedlist>
3738 </para>
3739 </sect3>
3740
3741 <sect3 id="instance-rules">
3742 <title>Relaxed rules for instance contexts</title>
3743
3744 <para>In Haskell 98, the assertions in the context of the instance declaration
3745 must be of the form <literal>C a</literal> where <literal>a</literal>
3746 is a type variable that occurs in the head.
3747 </para>
3748
3749 <para>
3750 The <option>-XFlexibleContexts</option> flag relaxes this rule, as well
3751 as the corresponding rule for type signatures (see <xref linkend="flexible-contexts"/>).
3752 With this flag the context of the instance declaration can each consist of arbitrary
3753 (well-kinded) assertions <literal>(C t1 ... tn)</literal> subject only to the
3754 following rules:
3755 <orderedlist>
3756 <listitem><para>
3757 The Paterson Conditions: for each assertion in the context
3758 <orderedlist>
3759 <listitem><para>No type variable has more occurrences in the assertion than in the head</para></listitem>
3760 <listitem><para>The assertion has fewer constructors and variables (taken together
3761       and counting repetitions) than the head</para></listitem>
3762 </orderedlist>
3763 </para></listitem>
3764
3765 <listitem><para>The Coverage Condition.  For each functional dependency,
3766 <replaceable>tvs</replaceable><subscript>left</subscript> <literal>-&gt;</literal>
3767 <replaceable>tvs</replaceable><subscript>right</subscript>,  of the class,
3768 every type variable in
3769 S(<replaceable>tvs</replaceable><subscript>right</subscript>) must appear in 
3770 S(<replaceable>tvs</replaceable><subscript>left</subscript>), where S is the
3771 substitution mapping each type variable in the class declaration to the
3772 corresponding type in the instance declaration.
3773 </para></listitem>
3774 </orderedlist>
3775 These restrictions ensure that context reduction terminates: each reduction
3776 step makes the problem smaller by at least one
3777 constructor.  Both the Paterson Conditions and the Coverage Condition are lifted 
3778 if you give the <option>-XUndecidableInstances</option> 
3779 flag (<xref linkend="undecidable-instances"/>).
3780 You can find lots of background material about the reason for these
3781 restrictions in the paper <ulink
3782 url="http://research.microsoft.com/%7Esimonpj/papers/fd%2Dchr/">
3783 Understanding functional dependencies via Constraint Handling Rules</ulink>.
3784 </para>
3785 <para>
3786 For example, these are OK:
3787 <programlisting>
3788   instance C Int [a]          -- Multiple parameters
3789   instance Eq (S [a])         -- Structured type in head
3790
3791       -- Repeated type variable in head
3792   instance C4 a a => C4 [a] [a] 
3793   instance Stateful (ST s) (MutVar s)
3794
3795       -- Head can consist of type variables only
3796   instance C a
3797   instance (Eq a, Show b) => C2 a b
3798
3799       -- Non-type variables in context
3800   instance Show (s a) => Show (Sized s a)
3801   instance C2 Int a => C3 Bool [a]
3802   instance C2 Int a => C3 [a] b
3803 </programlisting>
3804 But these are not:
3805 <programlisting>
3806       -- Context assertion no smaller than head
3807   instance C a => C a where ...
3808       -- (C b b) has more more occurrences of b than the head
3809   instance C b b => Foo [b] where ...
3810 </programlisting>
3811 </para>
3812
3813 <para>
3814 The same restrictions apply to instances generated by
3815 <literal>deriving</literal> clauses.  Thus the following is accepted:
3816 <programlisting>
3817   data MinHeap h a = H a (h a)
3818     deriving (Show)
3819 </programlisting>
3820 because the derived instance
3821 <programlisting>
3822   instance (Show a, Show (h a)) => Show (MinHeap h a)
3823 </programlisting>
3824 conforms to the above rules.
3825 </para>
3826
3827 <para>
3828 A useful idiom permitted by the above rules is as follows.
3829 If one allows overlapping instance declarations then it's quite
3830 convenient to have a "default instance" declaration that applies if
3831 something more specific does not:
3832 <programlisting>
3833   instance C a where
3834     op = ... -- Default
3835 </programlisting>
3836 </para>
3837 </sect3>
3838
3839 <sect3 id="undecidable-instances">
3840 <title>Undecidable instances</title>
3841
3842 <para>
3843 Sometimes even the rules of <xref linkend="instance-rules"/> are too onerous.
3844 For example, sometimes you might want to use the following to get the
3845 effect of a "class synonym":
3846 <programlisting>
3847   class (C1 a, C2 a, C3 a) => C a where { }
3848
3849   instance (C1 a, C2 a, C3 a) => C a where { }
3850 </programlisting>
3851 This allows you to write shorter signatures:
3852 <programlisting>
3853   f :: C a => ...
3854 </programlisting>
3855 instead of
3856 <programlisting>
3857   f :: (C1 a, C2 a, C3 a) => ...
3858 </programlisting>
3859 The restrictions on functional dependencies (<xref
3860 linkend="functional-dependencies"/>) are particularly troublesome.
3861 It is tempting to introduce type variables in the context that do not appear in
3862 the head, something that is excluded by the normal rules. For example:
3863 <programlisting>
3864   class HasConverter a b | a -> b where
3865      convert :: a -> b
3866    
3867   data Foo a = MkFoo a
3868
3869   instance (HasConverter a b,Show b) => Show (Foo a) where
3870      show (MkFoo value) = show (convert value)
3871 </programlisting>
3872 This is dangerous territory, however. Here, for example, is a program that would make the
3873 typechecker loop:
3874 <programlisting>
3875   class D a
3876   class F a b | a->b
3877   instance F [a] [[a]]
3878   instance (D c, F a c) => D [a]   -- 'c' is not mentioned in the head
3879 </programlisting>
3880 Similarly, it can be tempting to lift the coverage condition:
3881 <programlisting>
3882   class Mul a b c | a b -> c where
3883         (.*.) :: a -> b -> c
3884
3885   instance Mul Int Int Int where (.*.) = (*)
3886   instance Mul Int Float Float where x .*. y = fromIntegral x * y
3887   instance Mul a b c => Mul a [b] [c] where x .*. v = map (x.*.) v
3888 </programlisting>
3889 The third instance declaration does not obey the coverage condition;
3890 and indeed the (somewhat strange) definition:
3891 <programlisting>
3892   f = \ b x y -> if b then x .*. [y] else y
3893 </programlisting>
3894 makes instance inference go into a loop, because it requires the constraint
3895 <literal>(Mul a [b] b)</literal>.
3896 </para>
3897 <para>
3898 Nevertheless, GHC allows you to experiment with more liberal rules.  If you use
3899 the experimental flag <option>-XUndecidableInstances</option>
3900 <indexterm><primary>-XUndecidableInstances</primary></indexterm>, 
3901 both the Paterson Conditions and the Coverage Condition
3902 (described in <xref linkend="instance-rules"/>) are lifted.  Termination is ensured by having a
3903 fixed-depth recursion stack.  If you exceed the stack depth you get a
3904 sort of backtrace, and the opportunity to increase the stack depth
3905 with <option>-fcontext-stack=</option><emphasis>N</emphasis>.
3906 </para>
3907
3908 </sect3>
3909
3910
3911 <sect3 id="instance-overlap">
3912 <title>Overlapping instances</title>
3913 <para>
3914 In general, <emphasis>GHC requires that that it be unambiguous which instance
3915 declaration
3916 should be used to resolve a type-class constraint</emphasis>. This behaviour
3917 can be modified by two flags: <option>-XOverlappingInstances</option>
3918 <indexterm><primary>-XOverlappingInstances
3919 </primary></indexterm> 
3920 and <option>-XIncoherentInstances</option>
3921 <indexterm><primary>-XIncoherentInstances
3922 </primary></indexterm>, as this section discusses.  Both these
3923 flags are dynamic flags, and can be set on a per-module basis, using 
3924 an <literal>OPTIONS_GHC</literal> pragma if desired (<xref linkend="source-file-options"/>).</para>
3925 <para>
3926 When GHC tries to resolve, say, the constraint <literal>C Int Bool</literal>,
3927 it tries to match every instance declaration against the
3928 constraint,
3929 by instantiating the head of the instance declaration.  For example, consider
3930 these declarations:
3931 <programlisting>
3932   instance context1 => C Int a     where ...  -- (A)
3933   instance context2 => C a   Bool  where ...  -- (B)
3934   instance context3 => C Int [a]   where ...  -- (C)
3935   instance context4 => C Int [Int] where ...  -- (D)
3936 </programlisting>
3937 The instances (A) and (B) match the constraint <literal>C Int Bool</literal>, 
3938 but (C) and (D) do not.  When matching, GHC takes
3939 no account of the context of the instance declaration
3940 (<literal>context1</literal> etc).
3941 GHC's default behaviour is that <emphasis>exactly one instance must match the
3942 constraint it is trying to resolve</emphasis>.  
3943 It is fine for there to be a <emphasis>potential</emphasis> of overlap (by
3944 including both declarations (A) and (B), say); an error is only reported if a 
3945 particular constraint matches more than one.
3946 </para>
3947
3948 <para>
3949 The <option>-XOverlappingInstances</option> flag instructs GHC to allow
3950 more than one instance to match, provided there is a most specific one.  For
3951 example, the constraint <literal>C Int [Int]</literal> matches instances (A),
3952 (C) and (D), but the last is more specific, and hence is chosen.  If there is no
3953 most-specific match, the program is rejected.
3954 </para>
3955 <para>
3956 However, GHC is conservative about committing to an overlapping instance.  For example:
3957 <programlisting>
3958   f :: [b] -> [b]
3959   f x = ...
3960 </programlisting>
3961 Suppose that from the RHS of <literal>f</literal> we get the constraint
3962 <literal>C Int [b]</literal>.  But
3963 GHC does not commit to instance (C), because in a particular
3964 call of <literal>f</literal>, <literal>b</literal> might be instantiate 
3965 to <literal>Int</literal>, in which case instance (D) would be more specific still.
3966 So GHC rejects the program.  
3967 (If you add the flag <option>-XIncoherentInstances</option>,
3968 GHC will instead pick (C), without complaining about 
3969 the problem of subsequent instantiations.)
3970 </para>
3971 <para>
3972 Notice that we gave a type signature to <literal>f</literal>, so GHC had to
3973 <emphasis>check</emphasis> that <literal>f</literal> has the specified type.  
3974 Suppose instead we do not give a type signature, asking GHC to <emphasis>infer</emphasis>
3975 it instead.  In this case, GHC will refrain from
3976 simplifying the constraint <literal>C Int [b]</literal> (for the same reason
3977 as before) but, rather than rejecting the program, it will infer the type
3978 <programlisting>
3979   f :: C Int [b] => [b] -> [b]
3980 </programlisting>
3981 That postpones the question of which instance to pick to the 
3982 call site for <literal>f</literal>
3983 by which time more is known about the type <literal>b</literal>.
3984 You can write this type signature yourself if you use the 
3985 <link linkend="flexible-contexts"><option>-XFlexibleContexts</option></link>
3986 flag.
3987 </para>
3988 <para>
3989 Exactly the same situation can arise in instance declarations themselves.  Suppose we have
3990 <programlisting>
3991   class Foo a where
3992      f :: a -> a
3993   instance Foo [b] where
3994      f x = ...
3995 </programlisting>
3996 and, as before, the constraint <literal>C Int [b]</literal> arises from <literal>f</literal>'s
3997 right hand side.  GHC will reject the instance, complaining as before that it does not know how to resolve
3998 the constraint <literal>C Int [b]</literal>, because it matches more than one instance
3999 declaration.  The solution is to postpone the choice by adding the constraint to the context
4000 of the instance declaration, thus:
4001 <programlisting>
4002   instance C Int [b] => Foo [b] where
4003      f x = ...
4004 </programlisting>
4005 (You need <link linkend="instance-rules"><option>-XFlexibleInstances</option></link> to do this.)
4006 </para>
4007 <para>
4008 Warning: overlapping instances must be used with care.  They 
4009 can give rise to incoherence (ie different instance choices are made
4010 in different parts of the program) even without <option>-XIncoherentInstances</option>. Consider:
4011 <programlisting>
4012 {-# LANGUAGE OverlappingInstances #-}
4013 module Help where
4014
4015     class MyShow a where
4016       myshow :: a -> String
4017
4018     instance MyShow a => MyShow [a] where
4019       myshow xs = concatMap myshow xs
4020
4021     showHelp :: MyShow a => [a] -> String
4022     showHelp xs = myshow xs
4023
4024 {-# LANGUAGE FlexibleInstances, OverlappingInstances #-}
4025 module Main where
4026     import Help
4027
4028     data T = MkT
4029
4030     instance MyShow T where
4031       myshow x = "Used generic instance"
4032
4033     instance MyShow [T] where
4034       myshow xs = "Used more specific instance"
4035
4036     main = do { print (myshow [MkT]); print (showHelp [MkT]) }
4037 </programlisting>
4038 In function <literal>showHelp</literal> GHC sees no overlapping
4039 instances, and so uses the <literal>MyShow [a]</literal> instance
4040 without complaint.  In the call to <literal>myshow</literal> in <literal>main</literal>,
4041 GHC resolves the <literal>MyShow [T]</literal> constraint using the overlapping
4042 instance declaration in module <literal>Main</literal>. As a result, 
4043 the program prints
4044 <programlisting>
4045   "Used more specific instance"
4046   "Used generic instance"
4047 </programlisting>
4048 (An alternative possible behaviour, not currently implemented, 
4049 would be to reject module <literal>Help</literal>
4050 on the grounds that a later instance declaration might overlap the local one.)
4051 </para>
4052 <para>
4053 The willingness to be overlapped or incoherent is a property of 
4054 the <emphasis>instance declaration</emphasis> itself, controlled by the
4055 presence or otherwise of the <option>-XOverlappingInstances</option> 
4056 and <option>-XIncoherentInstances</option> flags when that module is
4057 being defined.  Neither flag is required in a module that imports and uses the
4058 instance declaration.  Specifically, during the lookup process:
4059 <itemizedlist>
4060 <listitem><para>
4061 An instance declaration is ignored during the lookup process if (a) a more specific
4062 match is found, and (b) the instance declaration was compiled with 
4063 <option>-XOverlappingInstances</option>.  The flag setting for the
4064 more-specific instance does not matter.
4065 </para></listitem>
4066 <listitem><para>
4067 Suppose an instance declaration does not match the constraint being looked up, but
4068 does unify with it, so that it might match when the constraint is further 
4069 instantiated.  Usually GHC will regard this as a reason for not committing to
4070 some other constraint.  But if the instance declaration was compiled with
4071 <option>-XIncoherentInstances</option>, GHC will skip the "does-it-unify?" 
4072 check for that declaration.
4073 </para></listitem>
4074 </itemizedlist>
4075 These rules make it possible for a library author to design a library that relies on 
4076 overlapping instances without the library client having to know.  
4077 </para>
4078 <para>
4079 If an instance declaration is compiled without
4080 <option>-XOverlappingInstances</option>,
4081 then that instance can never be overlapped.  This could perhaps be
4082 inconvenient.  Perhaps the rule should instead say that the
4083 <emphasis>overlapping</emphasis> instance declaration should be compiled in
4084 this way, rather than the <emphasis>overlapped</emphasis> one.  Perhaps overlap
4085 at a usage site should be permitted regardless of how the instance declarations
4086 are compiled, if the <option>-XOverlappingInstances</option> flag is
4087 used at the usage site.  (Mind you, the exact usage site can occasionally be
4088 hard to pin down.)  We are interested to receive feedback on these points.
4089 </para>
4090 <para>The <option>-XIncoherentInstances</option> flag implies the
4091 <option>-XOverlappingInstances</option> flag, but not vice versa.
4092 </para>
4093 </sect3>
4094
4095
4096
4097 </sect2>
4098
4099 <sect2 id="overloaded-strings">
4100 <title>Overloaded string literals
4101 </title>
4102
4103 <para>
4104 GHC supports <emphasis>overloaded string literals</emphasis>.  Normally a
4105 string literal has type <literal>String</literal>, but with overloaded string
4106 literals enabled (with <literal>-XOverloadedStrings</literal>)
4107  a string literal has type <literal>(IsString a) => a</literal>.
4108 </para>
4109 <para>
4110 This means that the usual string syntax can be used, e.g., for packed strings
4111 and other variations of string like types.  String literals behave very much
4112 like integer literals, i.e., they can be used in both expressions and patterns.
4113 If used in a pattern the literal with be replaced by an equality test, in the same
4114 way as an integer literal is.
4115 </para>
4116 <para>
4117 The class <literal>IsString</literal> is defined as:
4118 <programlisting>
4119 class IsString a where
4120     fromString :: String -> a
4121 </programlisting>
4122 The only predefined instance is the obvious one to make strings work as usual:
4123 <programlisting>
4124 instance IsString [Char] where
4125     fromString cs = cs
4126 </programlisting>
4127 The class <literal>IsString</literal> is not in scope by default.  If you want to mention
4128 it explicitly (for example, to give an instance declaration for it), you can import it
4129 from module <literal>GHC.Exts</literal>.
4130 </para>
4131 <para>
4132 Haskell's defaulting mechanism is extended to cover string literals, when <option>-XOverloadedStrings</option> is specified.
4133 Specifically:
4134 <itemizedlist>
4135 <listitem><para>
4136 Each type in a default declaration must be an 
4137 instance of <literal>Num</literal> <emphasis>or</emphasis> of <literal>IsString</literal>.
4138 </para></listitem>
4139
4140 <listitem><para>
4141 The standard defaulting rule (<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.3.4">Haskell Report, Section 4.3.4</ulink>)
4142 is extended thus: defaulting applies when all the unresolved constraints involve standard classes
4143 <emphasis>or</emphasis> <literal>IsString</literal>; and at least one is a numeric class
4144 <emphasis>or</emphasis> <literal>IsString</literal>.
4145 </para></listitem>
4146 </itemizedlist>
4147 </para>
4148 <para>
4149 A small example:
4150 <programlisting>
4151 module Main where
4152
4153 import GHC.Exts( IsString(..) )
4154
4155 newtype MyString = MyString String deriving (Eq, Show)
4156 instance IsString MyString where
4157     fromString = MyString
4158
4159 greet :: MyString -> MyString
4160 greet "hello" = "world"
4161 greet other = other
4162
4163 main = do
4164     print $ greet "hello"
4165     print $ greet "fool"
4166 </programlisting>
4167 </para>
4168 <para>
4169 Note that deriving <literal>Eq</literal> is necessary for the pattern matching
4170 to work since it gets translated into an equality comparison.
4171 </para>
4172 </sect2>
4173