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
4174 </sect1>
4175
4176 <sect1 id="type-families">
4177 <title>Type families</title>
4178
4179 <para>
4180   <firstterm>Indexed type families</firstterm> are a new GHC extension to
4181   facilitate type-level
4182   programming. Type families are a generalisation of <firstterm>associated
4183   data types</firstterm>
4184   (&ldquo;<ulink url="http://www.cse.unsw.edu.au/~chak/papers/CKPM05.html">Associated
4185   Types with Class</ulink>&rdquo;, M. Chakravarty, G. Keller, S. Peyton Jones,
4186   and S. Marlow. In Proceedings of &ldquo;The 32nd Annual ACM SIGPLAN-SIGACT
4187      Symposium on Principles of Programming Languages (POPL'05)&rdquo;, pages
4188   1-13, ACM Press, 2005) and <firstterm>associated type synonyms</firstterm>
4189   (&ldquo;<ulink url="http://www.cse.unsw.edu.au/~chak/papers/CKP05.html">Type
4190   Associated Type Synonyms</ulink>&rdquo;. M. Chakravarty, G. Keller, and
4191   S. Peyton Jones.
4192   In Proceedings of &ldquo;The Tenth ACM SIGPLAN International Conference on
4193   Functional Programming&rdquo;, ACM Press, pages 241-253, 2005).  Type families
4194   themselves are described in the paper &ldquo;<ulink
4195   url="http://www.cse.unsw.edu.au/~chak/papers/SPCS08.html">Type
4196   Checking with Open Type Functions</ulink>&rdquo;, T. Schrijvers,
4197   S. Peyton-Jones,
4198   M. Chakravarty, and M. Sulzmann, in Proceedings of &ldquo;ICFP 2008: The
4199   13th ACM SIGPLAN International Conference on Functional
4200   Programming&rdquo;, ACM Press, pages 51-62, 2008. Type families
4201   essentially provide type-indexed data types and named functions on types,
4202   which are useful for generic programming and highly parameterised library
4203   interfaces as well as interfaces with enhanced static information, much like
4204   dependent types. They might also be regarded as an alternative to functional
4205   dependencies, but provide a more functional style of type-level programming
4206   than the relational style of functional dependencies.
4207 </para>
4208 <para>
4209   Indexed type families, or type families for short, are type constructors that
4210   represent sets of types. Set members are denoted by supplying the type family
4211   constructor with type parameters, which are called <firstterm>type
4212   indices</firstterm>. The
4213   difference between vanilla parametrised type constructors and family
4214   constructors is much like between parametrically polymorphic functions and
4215   (ad-hoc polymorphic) methods of type classes. Parametric polymorphic functions
4216   behave the same at all type instances, whereas class methods can change their
4217   behaviour in dependence on the class type parameters. Similarly, vanilla type
4218   constructors imply the same data representation for all type instances, but
4219   family constructors can have varying representation types for varying type
4220   indices.
4221 </para>
4222 <para>
4223   Indexed type families come in two flavours: <firstterm>data
4224     families</firstterm> and <firstterm>type synonym
4225     families</firstterm>. They are the indexed family variants of algebraic
4226   data types and type synonyms, respectively. The instances of data families
4227   can be data types and newtypes.
4228 </para>
4229 <para>
4230   Type families are enabled by the flag <option>-XTypeFamilies</option>.
4231   Additional information on the use of type families in GHC is available on
4232   <ulink url="http://www.haskell.org/haskellwiki/GHC/Indexed_types">the
4233   Haskell wiki page on type families</ulink>.
4234 </para>
4235
4236 <sect2 id="data-families">
4237   <title>Data families</title>
4238
4239   <para>
4240     Data families appear in two flavours: (1) they can be defined on the
4241     toplevel
4242     or (2) they can appear inside type classes (in which case they are known as
4243     associated types). The former is the more general variant, as it lacks the
4244     requirement for the type-indexes to coincide with the class
4245     parameters. However, the latter can lead to more clearly structured code and
4246     compiler warnings if some type instances were - possibly accidentally -
4247     omitted. In the following, we always discuss the general toplevel form first
4248     and then cover the additional constraints placed on associated types.
4249   </para>
4250
4251   <sect3 id="data-family-declarations">
4252     <title>Data family declarations</title>
4253
4254     <para>
4255       Indexed data families are introduced by a signature, such as
4256 <programlisting>
4257 data family GMap k :: * -> *
4258 </programlisting>
4259       The special <literal>family</literal> distinguishes family from standard
4260       data declarations.  The result kind annotation is optional and, as
4261       usual, defaults to <literal>*</literal> if omitted.  An example is
4262 <programlisting>
4263 data family Array e
4264 </programlisting>
4265       Named arguments can also be given explicit kind signatures if needed.
4266       Just as with
4267       [http://www.haskell.org/ghc/docs/latest/html/users_guide/gadt.html GADT
4268       declarations] named arguments are entirely optional, so that we can
4269       declare <literal>Array</literal> alternatively with
4270 <programlisting>
4271 data family Array :: * -> *
4272 </programlisting>
4273     </para>
4274
4275     <sect4 id="assoc-data-family-decl">
4276       <title>Associated data family declarations</title>
4277       <para>
4278         When a data family is declared as part of a type class, we drop
4279         the <literal>family</literal> special.  The <literal>GMap</literal>
4280         declaration takes the following form
4281 <programlisting>
4282 class GMapKey k where
4283   data GMap k :: * -> *
4284   ...
4285 </programlisting>
4286         In contrast to toplevel declarations, named arguments must be used for
4287         all type parameters that are to be used as type-indexes.  Moreover,
4288         the argument names must be class parameters.  Each class parameter may
4289         only be used at most once per associated type, but some may be omitted
4290         and they may be in an order other than in the class head.  Hence, the
4291         following contrived example is admissible:
4292 <programlisting>
4293   class C a b c where
4294   data T c a :: *
4295 </programlisting>
4296       </para>
4297     </sect4>
4298   </sect3>
4299
4300   <sect3 id="data-instance-declarations">
4301     <title>Data instance declarations</title>
4302
4303     <para>
4304       Instance declarations of data and newtype families are very similar to
4305       standard data and newtype declarations.  The only two differences are
4306       that the keyword <literal>data</literal> or <literal>newtype</literal>
4307       is followed by <literal>instance</literal> and that some or all of the
4308       type arguments can be non-variable types, but may not contain forall
4309       types or type synonym families.  However, data families are generally
4310       allowed in type parameters, and type synonyms are allowed as long as
4311       they are fully applied and expand to a type that is itself admissible -
4312       exactly as this is required for occurrences of type synonyms in class
4313       instance parameters.  For example, the <literal>Either</literal>
4314       instance for <literal>GMap</literal> is
4315 <programlisting>
4316 data instance GMap (Either a b) v = GMapEither (GMap a v) (GMap b v)
4317 </programlisting>
4318       In this example, the declaration has only one variant.  In general, it
4319       can be any number.
4320     </para>
4321     <para>
4322       Data and newtype instance declarations are only permitted when an
4323       appropriate family declaration is in scope - just as a class instance declaratoin
4324       requires the class declaration to be visible.  Moreover, each instance
4325       declaration has to conform to the kind determined by its family
4326       declaration.  This implies that the number of parameters of an instance
4327       declaration matches the arity determined by the kind of the family.
4328     </para>
4329     <para>
4330       A data family instance declaration can use the full exprssiveness of
4331       ordinary <literal>data</literal> or <literal>newtype</literal> declarations:
4332       <itemizedlist>
4333       <listitem><para> Although, a data family is <emphasis>introduced</emphasis> with
4334       the keyword "<literal>data</literal>", a data family <emphasis>instance</emphasis> can
4335       use either <literal>data</literal> or <literal>newtype</literal>. For example:
4336 <programlisting>
4337 data family T a
4338 data    instance T Int  = T1 Int | T2 Bool
4339 newtype instance T Char = TC Bool
4340 </programlisting>
4341       </para></listitem>
4342       <listitem><para> A <literal>data instance</literal> can use GADT syntax for the data constructors,
4343       and indeed can define a GADT.  For example:
4344 <programlisting>
4345 data family G a b
4346 data instance G [a] b where
4347    G1 :: c -> G [Int] b
4348    G2 :: G [a] Bool
4349 </programlisting>
4350       </para></listitem>
4351       <listitem><para> You can use a <literal>deriving</literal> clause on a
4352       <literal>data instance</literal> or <literal>newtype instance</literal>
4353       declaration.
4354       </para></listitem>
4355       </itemizedlist>
4356     </para>
4357
4358     <para>
4359       Even if type families are defined as toplevel declarations, functions
4360       that perform different computations for different family instances may still
4361       need to be defined as methods of type classes.  In particular, the
4362       following is not possible:
4363 <programlisting>
4364 data family T a
4365 data instance T Int  = A
4366 data instance T Char = B
4367 foo :: T a -> Int
4368 foo A = 1             -- WRONG: These two equations together...
4369 foo B = 2             -- ...will produce a type error.
4370 </programlisting>
4371 Instead, you would have to write <literal>foo</literal> as a class operation, thus:
4372 <programlisting>
4373 class C a where
4374   foo :: T a -> Int
4375 instance Foo Int where
4376   foo A = 1
4377 instance Foo Char where
4378   foo B = 2
4379 </programlisting>
4380       (Given the functionality provided by GADTs (Generalised Algebraic Data
4381       Types), it might seem as if a definition, such as the above, should be
4382       feasible.  However, type families are - in contrast to GADTs - are
4383       <emphasis>open;</emphasis> i.e., new instances can always be added,
4384       possibly in other
4385       modules.  Supporting pattern matching across different data instances
4386       would require a form of extensible case construct.)
4387     </para>
4388
4389     <sect4 id="assoc-data-inst">
4390       <title>Associated data instances</title>
4391       <para>
4392         When an associated data family instance is declared within a type
4393         class instance, we drop the <literal>instance</literal> keyword in the
4394         family instance.  So, the <literal>Either</literal> instance
4395         for <literal>GMap</literal> becomes:
4396 <programlisting>
4397 instance (GMapKey a, GMapKey b) => GMapKey (Either a b) where
4398   data GMap (Either a b) v = GMapEither (GMap a v) (GMap b v)
4399   ...
4400 </programlisting>
4401         The most important point about associated family instances is that the
4402         type indexes corresponding to class parameters must be identical to
4403         the type given in the instance head; here this is the first argument
4404         of <literal>GMap</literal>, namely <literal>Either a b</literal>,
4405         which coincides with the only class parameter.  Any parameters to the
4406         family constructor that do not correspond to class parameters, need to
4407         be variables in every instance; here this is the
4408         variable <literal>v</literal>.
4409       </para>
4410       <para>
4411         Instances for an associated family can only appear as part of
4412         instances declarations of the class in which the family was declared -
4413         just as with the equations of the methods of a class.  Also in
4414         correspondence to how methods are handled, declarations of associated
4415         types can be omitted in class instances.  If an associated family
4416         instance is omitted, the corresponding instance type is not inhabited;
4417         i.e., only diverging expressions, such
4418         as <literal>undefined</literal>, can assume the type.
4419       </para>
4420     </sect4>
4421
4422     <sect4 id="scoping-class-params">
4423       <title>Scoping of class parameters</title>
4424       <para>
4425         In the case of multi-parameter type classes, the visibility of class
4426         parameters in the right-hand side of associated family instances
4427         depends <emphasis>solely</emphasis> on the parameters of the data
4428         family.  As an example, consider the simple class declaration
4429 <programlisting>
4430 class C a b where
4431   data T a
4432 </programlisting>
4433         Only one of the two class parameters is a parameter to the data
4434         family.  Hence, the following instance declaration is invalid:
4435 <programlisting>
4436 instance C [c] d where
4437   data T [c] = MkT (c, d)    -- WRONG!!  'd' is not in scope
4438 </programlisting>
4439         Here, the right-hand side of the data instance mentions the type
4440         variable <literal>d</literal> that does not occur in its left-hand
4441         side.  We cannot admit such data instances as they would compromise
4442         type safety.
4443       </para>
4444     </sect4>
4445
4446     <sect4 id="family-class-inst">
4447       <title>Type class instances of family instances</title>
4448       <para>
4449         Type class instances of instances of data families can be defined as
4450         usual, and in particular data instance declarations can
4451         have <literal>deriving</literal> clauses.  For example, we can write
4452 <programlisting>
4453 data GMap () v = GMapUnit (Maybe v)
4454                deriving Show
4455 </programlisting>
4456         which implicitly defines an instance of the form
4457 <programlisting>
4458 instance Show v => Show (GMap () v) where ...
4459 </programlisting>
4460       </para>
4461       <para>
4462         Note that class instances are always for
4463         particular <emphasis>instances</emphasis> of a data family and never
4464         for an entire family as a whole.  This is for essentially the same
4465         reasons that we cannot define a toplevel function that performs
4466         pattern matching on the data constructors
4467         of <emphasis>different</emphasis> instances of a single type family.
4468         It would require a form of extensible case construct.
4469       </para>
4470     </sect4>
4471
4472     <sect4 id="data-family-overlap">
4473       <title>Overlap of data instances</title>
4474       <para>
4475         The instance declarations of a data family used in a single program
4476         may not overlap at all, independent of whether they are associated or
4477         not.  In contrast to type class instances, this is not only a matter
4478         of consistency, but one of type safety.
4479       </para>
4480     </sect4>
4481
4482   </sect3>
4483
4484   <sect3 id="data-family-import-export">
4485     <title>Import and export</title>
4486
4487     <para>
4488       The association of data constructors with type families is more dynamic
4489       than that is the case with standard data and newtype declarations.  In
4490       the standard case, the notation <literal>T(..)</literal> in an import or
4491       export list denotes the type constructor and all the data constructors
4492       introduced in its declaration.  However, a family declaration never
4493       introduces any data constructors; instead, data constructors are
4494       introduced by family instances.  As a result, which data constructors
4495       are associated with a type family depends on the currently visible
4496       instance declarations for that family.  Consequently, an import or
4497       export item of the form <literal>T(..)</literal> denotes the family
4498       constructor and all currently visible data constructors - in the case of
4499       an export item, these may be either imported or defined in the current
4500       module.  The treatment of import and export items that explicitly list
4501       data constructors, such as <literal>GMap(GMapEither)</literal>, is
4502       analogous.
4503     </para>
4504
4505     <sect4 id="data-family-impexp-assoc">
4506       <title>Associated families</title>
4507       <para>
4508         As expected, an import or export item of the
4509         form <literal>C(..)</literal> denotes all of the class' methods and
4510         associated types.  However, when associated types are explicitly
4511         listed as subitems of a class, we need some new syntax, as uppercase
4512         identifiers as subitems are usually data constructors, not type
4513         constructors.  To clarify that we denote types here, each associated
4514         type name needs to be prefixed by the keyword <literal>type</literal>.
4515         So for example, when explicitly listing the components of
4516         the <literal>GMapKey</literal> class, we write <literal>GMapKey(type
4517         GMap, empty, lookup, insert)</literal>.
4518       </para>
4519     </sect4>
4520
4521     <sect4 id="data-family-impexp-examples">
4522       <title>Examples</title>
4523       <para>
4524         Assuming our running <literal>GMapKey</literal> class example, let us
4525         look at some export lists and their meaning:
4526         <itemizedlist>
4527           <listitem>
4528             <para><literal>module GMap (GMapKey) where...</literal>: Exports
4529               just the class name.</para>
4530           </listitem>
4531           <listitem>
4532             <para><literal>module GMap (GMapKey(..)) where...</literal>:
4533               Exports the class, the associated type <literal>GMap</literal>
4534               and the member
4535               functions <literal>empty</literal>, <literal>lookup</literal>,
4536               and <literal>insert</literal>.  None of the data constructors is
4537               exported.</para>
4538           </listitem>
4539           <listitem>
4540             <para><literal>module GMap (GMapKey(..), GMap(..))
4541                 where...</literal>: As before, but also exports all the data
4542               constructors <literal>GMapInt</literal>,
4543               <literal>GMapChar</literal>,
4544               <literal>GMapUnit</literal>, <literal>GMapPair</literal>,
4545               and <literal>GMapUnit</literal>.</para>
4546           </listitem>
4547           <listitem>
4548             <para><literal>module GMap (GMapKey(empty, lookup, insert),
4549             GMap(..)) where...</literal>: As before.</para>
4550           </listitem>
4551           <listitem>
4552             <para><literal>module GMap (GMapKey, empty, lookup, insert, GMap(..))
4553                 where...</literal>: As before.</para>
4554           </listitem>
4555         </itemizedlist>
4556       </para>
4557       <para>
4558         Finally, you can write <literal>GMapKey(type GMap)</literal> to denote
4559         both the class <literal>GMapKey</literal> as well as its associated
4560         type <literal>GMap</literal>.  However, you cannot
4561         write <literal>GMapKey(type GMap(..))</literal> &mdash; i.e.,
4562         sub-component specifications cannot be nested.  To
4563         specify <literal>GMap</literal>'s data constructors, you have to list
4564         it separately.
4565       </para>
4566     </sect4>
4567
4568     <sect4 id="data-family-impexp-instances">
4569       <title>Instances</title>
4570       <para>
4571         Family instances are implicitly exported, just like class instances.
4572         However, this applies only to the heads of instances, not to the data
4573         constructors an instance defines.
4574       </para>
4575     </sect4>
4576
4577   </sect3>
4578
4579 </sect2>
4580
4581 <sect2 id="synonym-families">
4582   <title>Synonym families</title>
4583
4584   <para>
4585     Type families appear in two flavours: (1) they can be defined on the
4586     toplevel or (2) they can appear inside type classes (in which case they
4587     are known as associated type synonyms).  The former is the more general
4588     variant, as it lacks the requirement for the type-indexes to coincide with
4589     the class parameters.  However, the latter can lead to more clearly
4590     structured code and compiler warnings if some type instances were -
4591     possibly accidentally - omitted.  In the following, we always discuss the
4592     general toplevel form first and then cover the additional constraints
4593     placed on associated types.
4594   </para>
4595
4596   <sect3 id="type-family-declarations">
4597     <title>Type family declarations</title>
4598
4599     <para>
4600       Indexed type families are introduced by a signature, such as
4601 <programlisting>
4602 type family Elem c :: *
4603 </programlisting>
4604       The special <literal>family</literal> distinguishes family from standard
4605       type declarations.  The result kind annotation is optional and, as
4606       usual, defaults to <literal>*</literal> if omitted.  An example is
4607 <programlisting>
4608 type family Elem c
4609 </programlisting>
4610       Parameters can also be given explicit kind signatures if needed.  We
4611       call the number of parameters in a type family declaration, the family's
4612       arity, and all applications of a type family must be fully saturated
4613       w.r.t. to that arity.  This requirement is unlike ordinary type synonyms
4614       and it implies that the kind of a type family is not sufficient to
4615       determine a family's arity, and hence in general, also insufficient to
4616       determine whether a type family application is well formed.  As an
4617       example, consider the following declaration:
4618 <programlisting>
4619 type family F a b :: * -> *   -- F's arity is 2,
4620                               -- although its overall kind is * -> * -> * -> *
4621 </programlisting>
4622       Given this declaration the following are examples of well-formed and
4623       malformed types:
4624 <programlisting>
4625 F Char [Int]       -- OK!  Kind: * -> *
4626 F Char [Int] Bool  -- OK!  Kind: *
4627 F IO Bool          -- WRONG: kind mismatch in the first argument
4628 F Bool             -- WRONG: unsaturated application
4629 </programlisting>
4630       </para>
4631
4632     <sect4 id="assoc-type-family-decl">
4633       <title>Associated type family declarations</title>
4634       <para>
4635         When a type family is declared as part of a type class, we drop
4636         the <literal>family</literal> special.  The <literal>Elem</literal>
4637         declaration takes the following form
4638 <programlisting>
4639 class Collects ce where
4640   type Elem ce :: *
4641   ...
4642 </programlisting>
4643         The argument names of the type family must be class parameters.  Each
4644         class parameter may only be used at most once per associated type, but
4645         some may be omitted and they may be in an order other than in the
4646         class head.  Hence, the following contrived example is admissible:
4647 <programlisting>
4648 class C a b c where
4649   type T c a :: *
4650 </programlisting>
4651         These rules are exactly as for associated data families.
4652       </para>
4653     </sect4>
4654   </sect3>
4655
4656   <sect3 id="type-instance-declarations">
4657     <title>Type instance declarations</title>
4658     <para>
4659       Instance declarations of type families are very similar to standard type
4660       synonym declarations.  The only two differences are that the
4661       keyword <literal>type</literal> is followed
4662       by <literal>instance</literal> and that some or all of the type
4663       arguments can be non-variable types, but may not contain forall types or
4664       type synonym families. However, data families are generally allowed, and
4665       type synonyms are allowed as long as they are fully applied and expand
4666       to a type that is admissible - these are the exact same requirements as
4667       for data instances.  For example, the <literal>[e]</literal> instance
4668       for <literal>Elem</literal> is
4669 <programlisting>
4670 type instance Elem [e] = e
4671 </programlisting>
4672     </para>
4673     <para>
4674       Type family instance declarations are only legitimate when an
4675       appropriate family declaration is in scope - just like class instances
4676       require the class declaration to be visible.  Moreover, each instance
4677       declaration has to conform to the kind determined by its family
4678       declaration, and the number of type parameters in an instance
4679       declaration must match the number of type parameters in the family
4680       declaration.   Finally, the right-hand side of a type instance must be a
4681       monotype (i.e., it may not include foralls) and after the expansion of
4682       all saturated vanilla type synonyms, no synonyms, except family synonyms
4683       may remain.  Here are some examples of admissible and illegal type
4684       instances:
4685 <programlisting>
4686 type family F a :: *
4687 type instance F [Int]              = Int         -- OK!
4688 type instance F String             = Char        -- OK!
4689 type instance F (F a)              = a           -- WRONG: type parameter mentions a type family
4690 type instance F (forall a. (a, b)) = b           -- WRONG: a forall type appears in a type parameter
4691 type instance F Float              = forall a.a  -- WRONG: right-hand side may not be a forall type
4692
4693 type family G a b :: * -> *
4694 type instance G Int            = (,)     -- WRONG: must be two type parameters
4695 type instance G Int Char Float = Double  -- WRONG: must be two type parameters
4696 </programlisting>
4697     </para>
4698
4699     <sect4 id="assoc-type-instance">
4700       <title>Associated type instance declarations</title>
4701       <para>
4702         When an associated family instance is declared within a type class
4703         instance, we drop the <literal>instance</literal> keyword in the family
4704         instance.  So, the <literal>[e]</literal> instance
4705         for <literal>Elem</literal> becomes:
4706 <programlisting>
4707 instance (Eq (Elem [e])) => Collects ([e]) where
4708   type Elem [e] = e
4709   ...
4710 </programlisting>
4711         The most important point about associated family instances is that the
4712         type indexes corresponding to class parameters must be identical to the
4713         type given in the instance head; here this is <literal>[e]</literal>,
4714         which coincides with the only class parameter.
4715       </para>
4716       <para>
4717         Instances for an associated family can only appear as part of  instances
4718         declarations of the class in which the family was declared - just as
4719         with the equations of the methods of a class.  Also in correspondence to
4720         how methods are handled, declarations of associated types can be omitted
4721         in class instances.  If an associated family instance is omitted, the
4722         corresponding instance type is not inhabited; i.e., only diverging
4723         expressions, such as <literal>undefined</literal>, can assume the type.
4724       </para>
4725     </sect4>
4726
4727     <sect4 id="type-family-overlap">
4728       <title>Overlap of type synonym instances</title>
4729       <para>
4730         The instance declarations of a type family used in a single program
4731         may only overlap if the right-hand sides of the overlapping instances
4732         coincide for the overlapping types.  More formally, two instance
4733         declarations overlap if there is a substitution that makes the
4734         left-hand sides of the instances syntactically the same.  Whenever
4735         that is the case, the right-hand sides of the instances must also be
4736         syntactically equal under the same substitution.  This condition is
4737         independent of whether the type family is associated or not, and it is
4738         not only a matter of consistency, but one of type safety.
4739       </para>
4740       <para>
4741         Here are two example to illustrate the condition under which overlap
4742         is permitted.
4743 <programlisting>
4744 type instance F (a, Int) = [a]
4745 type instance F (Int, b) = [b]   -- overlap permitted
4746
4747 type instance G (a, Int)  = [a]
4748 type instance G (Char, a) = [a]  -- ILLEGAL overlap, as [Char] /= [Int]
4749 </programlisting>
4750       </para>
4751     </sect4>
4752
4753     <sect4 id="type-family-decidability">
4754       <title>Decidability of type synonym instances</title>
4755       <para>
4756         In order to guarantee that type inference in the presence of type
4757         families decidable, we need to place a number of additional
4758         restrictions on the formation of type instance declarations (c.f.,
4759         Definition 5 (Relaxed Conditions) of &ldquo;<ulink
4760         url="http://www.cse.unsw.edu.au/~chak/papers/SPCS08.html">Type
4761           Checking with Open Type Functions</ulink>&rdquo;).  Instance
4762           declarations have the general form
4763 <programlisting>
4764 type instance F t1 .. tn = t
4765 </programlisting>
4766         where we require that for every type family application <literal>(G s1
4767         .. sm)</literal> in <literal>t</literal>,
4768         <orderedlist>
4769           <listitem>
4770             <para><literal>s1 .. sm</literal> do not contain any type family
4771             constructors,</para>
4772           </listitem>
4773           <listitem>
4774             <para>the total number of symbols (data type constructors and type
4775             variables) in <literal>s1 .. sm</literal> is strictly smaller than
4776             in <literal>t1 .. tn</literal>, and</para>
4777           </listitem>
4778           <listitem>
4779             <para>for every type
4780             variable <literal>a</literal>, <literal>a</literal> occurs
4781             in <literal>s1 .. sm</literal> at most as often as in <literal>t1
4782             .. tn</literal>.</para>
4783           </listitem>
4784         </orderedlist>
4785         These restrictions are easily verified and ensure termination of type
4786         inference.  However, they are not sufficient to guarantee completeness
4787         of type inference in the presence of, so called, ''loopy equalities'',
4788         such as <literal>a ~ [F a]</literal>, where a recursive occurrence of
4789         a type variable is underneath a family application and data
4790         constructor application - see the above mentioned paper for details.
4791       </para>
4792       <para>
4793         If the option <option>-XUndecidableInstances</option> is passed to the
4794         compiler, the above restrictions are not enforced and it is on the
4795         programmer to ensure termination of the normalisation of type families
4796         during type inference.
4797       </para>
4798     </sect4>
4799   </sect3>
4800
4801   <sect3 id-="equality-constraints">
4802     <title>Equality constraints</title>
4803     <para>
4804       Type context can include equality constraints of the form <literal>t1 ~
4805       t2</literal>, which denote that the types <literal>t1</literal>
4806       and <literal>t2</literal> need to be the same.  In the presence of type
4807       families, whether two types are equal cannot generally be decided
4808       locally.  Hence, the contexts of function signatures may include
4809       equality constraints, as in the following example:
4810 <programlisting>
4811 sumCollects :: (Collects c1, Collects c2, Elem c1 ~ Elem c2) => c1 -> c2 -> c2
4812 </programlisting>
4813       where we require that the element type of <literal>c1</literal>
4814       and <literal>c2</literal> are the same.  In general, the
4815       types <literal>t1</literal> and <literal>t2</literal> of an equality
4816       constraint may be arbitrary monotypes; i.e., they may not contain any
4817       quantifiers, independent of whether higher-rank types are otherwise
4818       enabled.
4819     </para>
4820     <para>
4821       Equality constraints can also appear in class and instance contexts.
4822       The former enable a simple translation of programs using functional
4823       dependencies into programs using family synonyms instead.  The general
4824       idea is to rewrite a class declaration of the form
4825 <programlisting>
4826 class C a b | a -> b
4827 </programlisting>
4828       to
4829 <programlisting>
4830 class (F a ~ b) => C a b where
4831   type F a
4832 </programlisting>
4833       That is, we represent every functional dependency (FD) <literal>a1 .. an
4834       -> b</literal> by an FD type family <literal>F a1 .. an</literal> and a
4835       superclass context equality <literal>F a1 .. an ~ b</literal>,
4836       essentially giving a name to the functional dependency.  In class
4837       instances, we define the type instances of FD families in accordance
4838       with the class head.  Method signatures are not affected by that
4839       process.
4840     </para>
4841     <para>
4842       NB: Equalities in superclass contexts are not fully implemented in
4843       GHC 6.10.
4844     </para>
4845   </sect3>
4846
4847   <sect3 id-="ty-fams-in-instances">
4848     <title>Type families and instance declarations</title>
4849     <para>Type families require us to extend the rules for
4850       the form of instance heads, which are given
4851       in <xref linkend="flexible-instance-head"/>.
4852       Specifically:
4853 <itemizedlist>
4854  <listitem><para>Data type families may appear in an instance head</para></listitem>
4855  <listitem><para>Type synonym families may not appear (at all) in an instance head</para></listitem>
4856 </itemizedlist>
4857 The reason for the latter restriction is that there is no way to check for. Consider
4858 <programlisting>
4859    type family F a
4860    type instance F Bool = Int
4861
4862    class C a
4863
4864    instance C Int
4865    instance C (F a)
4866 </programlisting>
4867 Now a constraint <literal>(C (F Bool))</literal> would match both instances.
4868 The situation is especially bad because the type instance for <literal>F Bool</literal>
4869 might be in another module, or even in a module that is not yet written.
4870 </para>
4871 </sect3>
4872 </sect2>
4873
4874 </sect1>
4875
4876 <sect1 id="other-type-extensions">
4877 <title>Other type system extensions</title>
4878
4879 <sect2 id="explicit-foralls"><title>Explicit universal quantification (forall)</title>
4880 <para>
4881 Haskell type signatures are implicitly quantified.  When the language option <option>-XExplicitForAll</option>
4882 is used, the keyword <literal>forall</literal>
4883 allows us to say exactly what this means.  For example:
4884 </para>
4885 <para>
4886 <programlisting>
4887         g :: b -> b
4888 </programlisting>
4889 means this:
4890 <programlisting>
4891         g :: forall b. (b -> b)
4892 </programlisting>
4893 The two are treated identically.
4894 </para>
4895 <para>
4896 Of course <literal>forall</literal> becomes a keyword; you can't use <literal>forall</literal> as
4897 a type variable any more!
4898 </para>
4899 </sect2>
4900
4901
4902 <sect2 id="flexible-contexts"><title>The context of a type signature</title>
4903 <para>
4904 The <option>-XFlexibleContexts</option> flag lifts the Haskell 98 restriction
4905 that the type-class constraints in a type signature must have the
4906 form <emphasis>(class type-variable)</emphasis> or
4907 <emphasis>(class (type-variable type-variable ...))</emphasis>.
4908 With <option>-XFlexibleContexts</option>
4909 these type signatures are perfectly OK
4910 <programlisting>
4911   g :: Eq [a] => ...
4912   g :: Ord (T a ()) => ...
4913 </programlisting>
4914 The flag <option>-XFlexibleContexts</option> also lifts the corresponding
4915 restriction on class declarations (<xref linkend="superclass-rules"/>) and instance declarations
4916 (<xref linkend="instance-rules"/>).
4917 </para>
4918
4919 <para>
4920 GHC imposes the following restrictions on the constraints in a type signature.
4921 Consider the type:
4922
4923 <programlisting>
4924   forall tv1..tvn (c1, ...,cn) => type
4925 </programlisting>
4926
4927 (Here, we write the "foralls" explicitly, although the Haskell source
4928 language omits them; in Haskell 98, all the free type variables of an
4929 explicit source-language type signature are universally quantified,
4930 except for the class type variables in a class declaration.  However,
4931 in GHC, you can give the foralls if you want.  See <xref linkend="explicit-foralls"/>).
4932 </para>
4933
4934 <para>
4935
4936 <orderedlist>
4937 <listitem>
4938
4939 <para>
4940  <emphasis>Each universally quantified type variable
4941 <literal>tvi</literal> must be reachable from <literal>type</literal></emphasis>.
4942
4943 A type variable <literal>a</literal> is "reachable" if it appears
4944 in the same constraint as either a type variable free in
4945 <literal>type</literal>, or another reachable type variable.
4946 A value with a type that does not obey
4947 this reachability restriction cannot be used without introducing
4948 ambiguity; that is why the type is rejected.
4949 Here, for example, is an illegal type:
4950
4951
4952 <programlisting>
4953   forall a. Eq a => Int
4954 </programlisting>
4955
4956
4957 When a value with this type was used, the constraint <literal>Eq tv</literal>
4958 would be introduced where <literal>tv</literal> is a fresh type variable, and
4959 (in the dictionary-translation implementation) the value would be
4960 applied to a dictionary for <literal>Eq tv</literal>.  The difficulty is that we
4961 can never know which instance of <literal>Eq</literal> to use because we never
4962 get any more information about <literal>tv</literal>.
4963 </para>
4964 <para>
4965 Note
4966 that the reachability condition is weaker than saying that <literal>a</literal> is
4967 functionally dependent on a type variable free in
4968 <literal>type</literal> (see <xref
4969 linkend="functional-dependencies"/>).  The reason for this is there
4970 might be a "hidden" dependency, in a superclass perhaps.  So
4971 "reachable" is a conservative approximation to "functionally dependent".
4972 For example, consider:
4973 <programlisting>
4974   class C a b | a -> b where ...
4975   class C a b => D a b where ...
4976   f :: forall a b. D a b => a -> a
4977 </programlisting>
4978 This is fine, because in fact <literal>a</literal> does functionally determine <literal>b</literal>
4979 but that is not immediately apparent from <literal>f</literal>'s type.
4980 </para>
4981 </listitem>
4982 <listitem>
4983
4984 <para>
4985  <emphasis>Every constraint <literal>ci</literal> must mention at least one of the
4986 universally quantified type variables <literal>tvi</literal></emphasis>.
4987
4988 For example, this type is OK because <literal>C a b</literal> mentions the
4989 universally quantified type variable <literal>b</literal>:
4990
4991
4992 <programlisting>
4993   forall a. C a b => burble
4994 </programlisting>
4995
4996
4997 The next type is illegal because the constraint <literal>Eq b</literal> does not
4998 mention <literal>a</literal>:
4999
5000
5001 <programlisting>
5002   forall a. Eq b => burble
5003 </programlisting>
5004
5005
5006 The reason for this restriction is milder than the other one.  The
5007 excluded types are never useful or necessary (because the offending
5008 context doesn't need to be witnessed at this point; it can be floated
5009 out).  Furthermore, floating them out increases sharing. Lastly,
5010 excluding them is a conservative choice; it leaves a patch of
5011 territory free in case we need it later.
5012
5013 </para>
5014 </listitem>
5015
5016 </orderedlist>
5017
5018 </para>
5019
5020 </sect2>
5021
5022 <sect2 id="implicit-parameters">
5023 <title>Implicit parameters</title>
5024
5025 <para> Implicit parameters are implemented as described in
5026 "Implicit parameters: dynamic scoping with static types",
5027 J Lewis, MB Shields, E Meijer, J Launchbury,
5028 27th ACM Symposium on Principles of Programming Languages (POPL'00),
5029 Boston, Jan 2000.
5030 </para>
5031
5032 <para>(Most of the following, still rather incomplete, documentation is
5033 due to Jeff Lewis.)</para>
5034
5035 <para>Implicit parameter support is enabled with the option
5036 <option>-XImplicitParams</option>.</para>
5037
5038 <para>
5039 A variable is called <emphasis>dynamically bound</emphasis> when it is bound by the calling
5040 context of a function and <emphasis>statically bound</emphasis> when bound by the callee's
5041 context. In Haskell, all variables are statically bound. Dynamic
5042 binding of variables is a notion that goes back to Lisp, but was later
5043 discarded in more modern incarnations, such as Scheme. Dynamic binding
5044 can be very confusing in an untyped language, and unfortunately, typed
5045 languages, in particular Hindley-Milner typed languages like Haskell,
5046 only support static scoping of variables.
5047 </para>
5048 <para>
5049 However, by a simple extension to the type class system of Haskell, we
5050 can support dynamic binding. Basically, we express the use of a
5051 dynamically bound variable as a constraint on the type. These
5052 constraints lead to types of the form <literal>(?x::t') => t</literal>, which says "this
5053 function uses a dynamically-bound variable <literal>?x</literal>
5054 of type <literal>t'</literal>". For
5055 example, the following expresses the type of a sort function,
5056 implicitly parameterized by a comparison function named <literal>cmp</literal>.
5057 <programlisting>
5058   sort :: (?cmp :: a -> a -> Bool) => [a] -> [a]
5059 </programlisting>
5060 The dynamic binding constraints are just a new form of predicate in the type class system.
5061 </para>
5062 <para>
5063 An implicit parameter occurs in an expression using the special form <literal>?x</literal>,
5064 where <literal>x</literal> is
5065 any valid identifier (e.g. <literal>ord ?x</literal> is a valid expression).
5066 Use of this construct also introduces a new
5067 dynamic-binding constraint in the type of the expression.
5068 For example, the following definition
5069 shows how we can define an implicitly parameterized sort function in
5070 terms of an explicitly parameterized <literal>sortBy</literal> function:
5071 <programlisting>
5072   sortBy :: (a -> a -> Bool) -> [a] -> [a]
5073
5074   sort   :: (?cmp :: a -> a -> Bool) => [a] -> [a]
5075   sort    = sortBy ?cmp
5076 </programlisting>
5077 </para>
5078
5079 <sect3>
5080 <title>Implicit-parameter type constraints</title>
5081 <para>
5082 Dynamic binding constraints behave just like other type class
5083 constraints in that they are automatically propagated. Thus, when a
5084 function is used, its implicit parameters are inherited by the
5085 function that called it. For example, our <literal>sort</literal> function might be used
5086 to pick out the least value in a list:
5087 <programlisting>
5088   least   :: (?cmp :: a -> a -> Bool) => [a] -> a
5089   least xs = head (sort xs)
5090 </programlisting>
5091 Without lifting a finger, the <literal>?cmp</literal> parameter is
5092 propagated to become a parameter of <literal>least</literal> as well. With explicit
5093 parameters, the default is that parameters must always be explicit
5094 propagated. With implicit parameters, the default is to always
5095 propagate them.
5096 </para>
5097 <para>
5098 An implicit-parameter type constraint differs from other type class constraints in the
5099 following way: All uses of a particular implicit parameter must have
5100 the same type. This means that the type of <literal>(?x, ?x)</literal>
5101 is <literal>(?x::a) => (a,a)</literal>, and not
5102 <literal>(?x::a, ?x::b) => (a, b)</literal>, as would be the case for type
5103 class constraints.
5104 </para>
5105
5106 <para> You can't have an implicit parameter in the context of a class or instance
5107 declaration.  For example, both these declarations are illegal:
5108 <programlisting>
5109   class (?x::Int) => C a where ...
5110   instance (?x::a) => Foo [a] where ...
5111 </programlisting>
5112 Reason: exactly which implicit parameter you pick up depends on exactly where
5113 you invoke a function. But the ``invocation'' of instance declarations is done
5114 behind the scenes by the compiler, so it's hard to figure out exactly where it is done.
5115 Easiest thing is to outlaw the offending types.</para>
5116 <para>
5117 Implicit-parameter constraints do not cause ambiguity.  For example, consider:
5118 <programlisting>
5119    f :: (?x :: [a]) => Int -> Int
5120    f n = n + length ?x
5121
5122    g :: (Read a, Show a) => String -> String
5123    g s = show (read s)
5124 </programlisting>
5125 Here, <literal>g</literal> has an ambiguous type, and is rejected, but <literal>f</literal>
5126 is fine.  The binding for <literal>?x</literal> at <literal>f</literal>'s call site is
5127 quite unambiguous, and fixes the type <literal>a</literal>.
5128 </para>
5129 </sect3>
5130
5131 <sect3>
5132 <title>Implicit-parameter bindings</title>
5133
5134 <para>
5135 An implicit parameter is <emphasis>bound</emphasis> using the standard
5136 <literal>let</literal> or <literal>where</literal> binding forms.
5137 For example, we define the <literal>min</literal> function by binding
5138 <literal>cmp</literal>.
5139 <programlisting>
5140   min :: [a] -> a
5141   min  = let ?cmp = (&lt;=) in least
5142 </programlisting>
5143 </para>
5144 <para>
5145 A group of implicit-parameter bindings may occur anywhere a normal group of Haskell
5146 bindings can occur, except at top level.  That is, they can occur in a <literal>let</literal>
5147 (including in a list comprehension, or do-notation, or pattern guards),
5148 or a <literal>where</literal> clause.
5149 Note the following points:
5150 <itemizedlist>
5151 <listitem><para>
5152 An implicit-parameter binding group must be a
5153 collection of simple bindings to implicit-style variables (no
5154 function-style bindings, and no type signatures); these bindings are
5155 neither polymorphic or recursive.
5156 </para></listitem>
5157 <listitem><para>
5158 You may not mix implicit-parameter bindings with ordinary bindings in a
5159 single <literal>let</literal>
5160 expression; use two nested <literal>let</literal>s instead.
5161 (In the case of <literal>where</literal> you are stuck, since you can't nest <literal>where</literal> clauses.)
5162 </para></listitem>
5163
5164 <listitem><para>
5165 You may put multiple implicit-parameter bindings in a
5166 single binding group; but they are <emphasis>not</emphasis> treated
5167 as a mutually recursive group (as ordinary <literal>let</literal> bindings are).
5168 Instead they are treated as a non-recursive group, simultaneously binding all the implicit
5169 parameter.  The bindings are not nested, and may be re-ordered without changing
5170 the meaning of the program.
5171 For example, consider:
5172 <programlisting>
5173   f t = let { ?x = t; ?y = ?x+(1::Int) } in ?x + ?y
5174 </programlisting>
5175 The use of <literal>?x</literal> in the binding for <literal>?y</literal> does not "see"
5176 the binding for <literal>?x</literal>, so the type of <literal>f</literal> is
5177 <programlisting>
5178   f :: (?x::Int) => Int -> Int
5179 </programlisting>
5180 </para></listitem>
5181 </itemizedlist>
5182 </para>
5183
5184 </sect3>
5185
5186 <sect3><title>Implicit parameters and polymorphic recursion</title>
5187
5188 <para>
5189 Consider these two definitions:
5190 <programlisting>
5191   len1 :: [a] -> Int
5192   len1 xs = let ?acc = 0 in len_acc1 xs
5193
5194   len_acc1 [] = ?acc
5195   len_acc1 (x:xs) = let ?acc = ?acc + (1::Int) in len_acc1 xs
5196
5197   ------------
5198
5199   len2 :: [a] -> Int
5200   len2 xs = let ?acc = 0 in len_acc2 xs
5201
5202   len_acc2 :: (?acc :: Int) => [a] -> Int
5203   len_acc2 [] = ?acc
5204   len_acc2 (x:xs) = let ?acc = ?acc + (1::Int) in len_acc2 xs
5205 </programlisting>
5206 The only difference between the two groups is that in the second group
5207 <literal>len_acc</literal> is given a type signature.
5208 In the former case, <literal>len_acc1</literal> is monomorphic in its own
5209 right-hand side, so the implicit parameter <literal>?acc</literal> is not
5210 passed to the recursive call.  In the latter case, because <literal>len_acc2</literal>
5211 has a type signature, the recursive call is made to the
5212 <emphasis>polymorphic</emphasis> version, which takes <literal>?acc</literal>
5213 as an implicit parameter.  So we get the following results in GHCi:
5214 <programlisting>
5215   Prog> len1 "hello"
5216   0
5217   Prog> len2 "hello"
5218   5
5219 </programlisting>
5220 Adding a type signature dramatically changes the result!  This is a rather
5221 counter-intuitive phenomenon, worth watching out for.
5222 </para>
5223 </sect3>
5224
5225 <sect3><title>Implicit parameters and monomorphism</title>
5226
5227 <para>GHC applies the dreaded Monomorphism Restriction (section 4.5.5 of the
5228 Haskell Report) to implicit parameters.  For example, consider:
5229 <programlisting>
5230  f :: Int -> Int
5231   f v = let ?x = 0     in
5232         let y = ?x + v in
5233         let ?x = 5     in
5234         y
5235 </programlisting>
5236 Since the binding for <literal>y</literal> falls under the Monomorphism
5237 Restriction it is not generalised, so the type of <literal>y</literal> is
5238 simply <literal>Int</literal>, not <literal>(?x::Int) => Int</literal>.
5239 Hence, <literal>(f 9)</literal> returns result <literal>9</literal>.
5240 If you add a type signature for <literal>y</literal>, then <literal>y</literal>
5241 will get type <literal>(?x::Int) => Int</literal>, so the occurrence of
5242 <literal>y</literal> in the body of the <literal>let</literal> will see the
5243 inner binding of <literal>?x</literal>, so <literal>(f 9)</literal> will return
5244 <literal>14</literal>.
5245 </para>
5246 </sect3>
5247 </sect2>
5248
5249     <!--   ======================= COMMENTED OUT ========================
5250
5251     We intend to remove linear implicit parameters, so I'm at least removing
5252     them from the 6.6 user manual
5253
5254 <sect2 id="linear-implicit-parameters">
5255 <title>Linear implicit parameters</title>
5256 <para>
5257 Linear implicit parameters are an idea developed by Koen Claessen,
5258 Mark Shields, and Simon PJ.  They address the long-standing
5259 problem that monads seem over-kill for certain sorts of problem, notably:
5260 </para>
5261 <itemizedlist>
5262 <listitem> <para> distributing a supply of unique names </para> </listitem>
5263 <listitem> <para> distributing a supply of random numbers </para> </listitem>
5264 <listitem> <para> distributing an oracle (as in QuickCheck) </para> </listitem>
5265 </itemizedlist>
5266
5267 <para>
5268 Linear implicit parameters are just like ordinary implicit parameters,
5269 except that they are "linear"; that is, they cannot be copied, and
5270 must be explicitly "split" instead.  Linear implicit parameters are
5271 written '<literal>%x</literal>' instead of '<literal>?x</literal>'.
5272 (The '/' in the '%' suggests the split!)
5273 </para>
5274 <para>
5275 For example:
5276 <programlisting>
5277     import GHC.Exts( Splittable )
5278
5279     data NameSupply = ...
5280
5281     splitNS :: NameSupply -> (NameSupply, NameSupply)
5282     newName :: NameSupply -> Name
5283
5284     instance Splittable NameSupply where
5285         split = splitNS
5286
5287
5288     f :: (%ns :: NameSupply) => Env -> Expr -> Expr
5289     f env (Lam x e) = Lam x' (f env e)
5290                     where
5291                       x'   = newName %ns
5292                       env' = extend env x x'
5293     ...more equations for f...
5294 </programlisting>
5295 Notice that the implicit parameter %ns is consumed
5296 <itemizedlist>
5297 <listitem> <para> once by the call to <literal>newName</literal> </para> </listitem>
5298 <listitem> <para> once by the recursive call to <literal>f</literal> </para></listitem>
5299 </itemizedlist>
5300 </para>
5301 <para>
5302 So the translation done by the type checker makes
5303 the parameter explicit:
5304 <programlisting>
5305     f :: NameSupply -> Env -> Expr -> Expr
5306     f ns env (Lam x e) = Lam x' (f ns1 env e)
5307                        where
5308                          (ns1,ns2) = splitNS ns
5309                          x' = newName ns2
5310                          env = extend env x x'
5311 </programlisting>
5312 Notice the call to 'split' introduced by the type checker.
5313 How did it know to use 'splitNS'?  Because what it really did
5314 was to introduce a call to the overloaded function 'split',
5315 defined by the class <literal>Splittable</literal>:
5316 <programlisting>
5317         class Splittable a where
5318           split :: a -> (a,a)
5319 </programlisting>
5320 The instance for <literal>Splittable NameSupply</literal> tells GHC how to implement
5321 split for name supplies.  But we can simply write
5322 <programlisting>
5323         g x = (x, %ns, %ns)
5324 </programlisting>
5325 and GHC will infer
5326 <programlisting>
5327         g :: (Splittable a, %ns :: a) => b -> (b,a,a)
5328 </programlisting>
5329 The <literal>Splittable</literal> class is built into GHC.  It's exported by module
5330 <literal>GHC.Exts</literal>.
5331 </para>
5332 <para>
5333 Other points:
5334 <itemizedlist>
5335 <listitem> <para> '<literal>?x</literal>' and '<literal>%x</literal>'
5336 are entirely distinct implicit parameters: you
5337   can use them together and they won't interfere with each other. </para>
5338 </listitem>
5339
5340 <listitem> <para> You can bind linear implicit parameters in 'with' clauses. </para> </listitem>
5341
5342 <listitem> <para>You cannot have implicit parameters (whether linear or not)
5343   in the context of a class or instance declaration. </para></listitem>
5344 </itemizedlist>
5345 </para>
5346
5347 <sect3><title>Warnings</title>
5348
5349 <para>
5350 The monomorphism restriction is even more important than usual.
5351 Consider the example above:
5352 <programlisting>
5353     f :: (%ns :: NameSupply) => Env -> Expr -> Expr
5354     f env (Lam x e) = Lam x' (f env e)
5355                     where
5356                       x'   = newName %ns
5357                       env' = extend env x x'
5358 </programlisting>
5359 If we replaced the two occurrences of x' by (newName %ns), which is
5360 usually a harmless thing to do, we get:
5361 <programlisting>
5362     f :: (%ns :: NameSupply) => Env -> Expr -> Expr
5363     f env (Lam x e) = Lam (newName %ns) (f env e)
5364                     where
5365                       env' = extend env x (newName %ns)
5366 </programlisting>
5367 But now the name supply is consumed in <emphasis>three</emphasis> places
5368 (the two calls to newName,and the recursive call to f), so
5369 the result is utterly different.  Urk!  We don't even have
5370 the beta rule.
5371 </para>
5372 <para>
5373 Well, this is an experimental change.  With implicit
5374 parameters we have already lost beta reduction anyway, and
5375 (as John Launchbury puts it) we can't sensibly reason about
5376 Haskell programs without knowing their typing.
5377 </para>
5378
5379 </sect3>
5380
5381 <sect3><title>Recursive functions</title>
5382 <para>Linear implicit parameters can be particularly tricky when you have a recursive function
5383 Consider
5384 <programlisting>
5385         foo :: %x::T => Int -> [Int]
5386         foo 0 = []
5387         foo n = %x : foo (n-1)
5388 </programlisting>
5389 where T is some type in class Splittable.</para>
5390 <para>
5391 Do you get a list of all the same T's or all different T's
5392 (assuming that split gives two distinct T's back)?
5393 </para><para>
5394 If you supply the type signature, taking advantage of polymorphic
5395 recursion, you get what you'd probably expect.  Here's the
5396 translated term, where the implicit param is made explicit:
5397 <programlisting>
5398         foo x 0 = []
5399         foo x n = let (x1,x2) = split x
5400                   in x1 : foo x2 (n-1)
5401 </programlisting>
5402 But if you don't supply a type signature, GHC uses the Hindley
5403 Milner trick of using a single monomorphic instance of the function
5404 for the recursive calls. That is what makes Hindley Milner type inference
5405 work.  So the translation becomes
5406 <programlisting>
5407         foo x = let
5408                   foom 0 = []
5409                   foom n = x : foom (n-1)
5410                 in
5411                 foom
5412 </programlisting>
5413 Result: 'x' is not split, and you get a list of identical T's.  So the
5414 semantics of the program depends on whether or not foo has a type signature.
5415 Yikes!
5416 </para><para>
5417 You may say that this is a good reason to dislike linear implicit parameters
5418 and you'd be right.  That is why they are an experimental feature.
5419 </para>
5420 </sect3>
5421
5422 </sect2>
5423
5424 ================ END OF Linear Implicit Parameters commented out -->
5425
5426 <sect2 id="kinding">
5427 <title>Explicitly-kinded quantification</title>
5428
5429 <para>
5430 Haskell infers the kind of each type variable.  Sometimes it is nice to be able
5431 to give the kind explicitly as (machine-checked) documentation,
5432 just as it is nice to give a type signature for a function.  On some occasions,
5433 it is essential to do so.  For example, in his paper "Restricted Data Types in Haskell" (Haskell Workshop 1999)
5434 John Hughes had to define the data type:
5435 <screen>
5436      data Set cxt a = Set [a]
5437                     | Unused (cxt a -> ())
5438 </screen>
5439 The only use for the <literal>Unused</literal> constructor was to force the correct
5440 kind for the type variable <literal>cxt</literal>.
5441 </para>
5442 <para>
5443 GHC now instead allows you to specify the kind of a type variable directly, wherever
5444 a type variable is explicitly bound, with the flag <option>-XKindSignatures</option>.
5445 </para>
5446 <para>
5447 This flag enables kind signatures in the following places:
5448 <itemizedlist>
5449 <listitem><para><literal>data</literal> declarations:
5450 <screen>
5451   data Set (cxt :: * -> *) a = Set [a]
5452 </screen></para></listitem>
5453 <listitem><para><literal>type</literal> declarations:
5454 <screen>
5455   type T (f :: * -> *) = f Int
5456 </screen></para></listitem>
5457 <listitem><para><literal>class</literal> declarations:
5458 <screen>
5459   class (Eq a) => C (f :: * -> *) a where ...
5460 </screen></para></listitem>
5461 <listitem><para><literal>forall</literal>'s in type signatures:
5462 <screen>
5463   f :: forall (cxt :: * -> *). Set cxt Int
5464 </screen></para></listitem>
5465 </itemizedlist>
5466 </para>
5467
5468 <para>
5469 The parentheses are required.  Some of the spaces are required too, to
5470 separate the lexemes.  If you write <literal>(f::*->*)</literal> you
5471 will get a parse error, because "<literal>::*->*</literal>" is a
5472 single lexeme in Haskell.
5473 </para>
5474
5475 <para>
5476 As part of the same extension, you can put kind annotations in types
5477 as well.  Thus:
5478 <screen>
5479    f :: (Int :: *) -> Int
5480    g :: forall a. a -> (a :: *)
5481 </screen>
5482 The syntax is
5483 <screen>
5484    atype ::= '(' ctype '::' kind ')
5485 </screen>
5486 The parentheses are required.
5487 </para>
5488 </sect2>
5489
5490
5491 <sect2 id="universal-quantification">
5492 <title>Arbitrary-rank polymorphism
5493 </title>
5494
5495 <para>
5496 GHC's type system supports <emphasis>arbitrary-rank</emphasis>
5497 explicit universal quantification in
5498 types.
5499 For example, all the following types are legal:
5500 <programlisting>
5501     f1 :: forall a b. a -> b -> a
5502     g1 :: forall a b. (Ord a, Eq  b) => a -> b -> a
5503
5504     f2 :: (forall a. a->a) -> Int -> Int
5505     g2 :: (forall a. Eq a => [a] -> a -> Bool) -> Int -> Int
5506
5507     f3 :: ((forall a. a->a) -> Int) -> Bool -> Bool
5508
5509     f4 :: Int -> (forall a. a -> a)
5510 </programlisting>
5511 Here, <literal>f1</literal> and <literal>g1</literal> are rank-1 types, and
5512 can be written in standard Haskell (e.g. <literal>f1 :: a->b->a</literal>).
5513 The <literal>forall</literal> makes explicit the universal quantification that
5514 is implicitly added by Haskell.
5515 </para>
5516 <para>
5517 The functions <literal>f2</literal> and <literal>g2</literal> have rank-2 types;
5518 the <literal>forall</literal> is on the left of a function arrow.  As <literal>g2</literal>
5519 shows, the polymorphic type on the left of the function arrow can be overloaded.
5520 </para>
5521 <para>
5522 The function <literal>f3</literal> has a rank-3 type;
5523 it has rank-2 types on the left of a function arrow.
5524 </para>
5525 <para>
5526 GHC has three flags to control higher-rank types:
5527 <itemizedlist>
5528 <listitem><para>
5529  <option>-XPolymorphicComponents</option>: data constructors (only) can have polymorphic argument types.
5530 </para></listitem>
5531 <listitem><para>
5532  <option>-XRank2Types</option>: any function (including data constructors) can have a rank-2 type.
5533 </para></listitem>
5534 <listitem><para>
5535  <option>-XRankNTypes</option>: any function (including data constructors) can have an arbitrary-rank type.
5536 That is,  you can nest <literal>forall</literal>s
5537 arbitrarily deep in function arrows.
5538 In particular, a forall-type (also called a "type scheme"),
5539 including an operational type class context, is legal:
5540 <itemizedlist>
5541 <listitem> <para> On the left or right (see <literal>f4</literal>, for example)
5542 of a function arrow </para> </listitem>
5543 <listitem> <para> As the argument of a constructor, or type of a field, in a data type declaration. For
5544 example, any of the <literal>f1,f2,f3,g1,g2</literal> above would be valid
5545 field type signatures.</para> </listitem>
5546 <listitem> <para> As the type of an implicit parameter </para> </listitem>
5547 <listitem> <para> In a pattern type signature (see <xref linkend="scoped-type-variables"/>) </para> </listitem>
5548 </itemizedlist>
5549 </para></listitem>
5550 </itemizedlist>
5551 </para>
5552
5553
5554 <sect3 id="univ">
5555 <title>Examples
5556 </title>
5557
5558 <para>
5559 In a <literal>data</literal> or <literal>newtype</literal> declaration one can quantify
5560 the types of the constructor arguments.  Here are several examples:
5561 </para>
5562
5563 <para>
5564
5565 <programlisting>
5566 data T a = T1 (forall b. b -> b -> b) a
5567
5568 data MonadT m = MkMonad { return :: forall a. a -> m a,
5569                           bind   :: forall a b. m a -> (a -> m b) -> m b
5570                         }
5571
5572 newtype Swizzle = MkSwizzle (Ord a => [a] -> [a])
5573 </programlisting>
5574
5575 </para>
5576
5577 <para>
5578 The constructors have rank-2 types:
5579 </para>
5580
5581 <para>
5582
5583 <programlisting>
5584 T1 :: forall a. (forall b. b -> b -> b) -> a -> T a
5585 MkMonad :: forall m. (forall a. a -> m a)
5586                   -> (forall a b. m a -> (a -> m b) -> m b)
5587                   -> MonadT m
5588 MkSwizzle :: (Ord a => [a] -> [a]) -> Swizzle
5589 </programlisting>
5590
5591 </para>
5592
5593 <para>
5594 Notice that you don't need to use a <literal>forall</literal> if there's an
5595 explicit context.  For example in the first argument of the
5596 constructor <function>MkSwizzle</function>, an implicit "<literal>forall a.</literal>" is
5597 prefixed to the argument type.  The implicit <literal>forall</literal>
5598 quantifies all type variables that are not already in scope, and are
5599 mentioned in the type quantified over.
5600 </para>
5601
5602 <para>
5603 As for type signatures, implicit quantification happens for non-overloaded
5604 types too.  So if you write this:
5605
5606 <programlisting>
5607   data T a = MkT (Either a b) (b -> b)
5608 </programlisting>
5609
5610 it's just as if you had written this:
5611
5612 <programlisting>
5613   data T a = MkT (forall b. Either a b) (forall b. b -> b)
5614 </programlisting>
5615
5616 That is, since the type variable <literal>b</literal> isn't in scope, it's
5617 implicitly universally quantified.  (Arguably, it would be better
5618 to <emphasis>require</emphasis> explicit quantification on constructor arguments
5619 where that is what is wanted.  Feedback welcomed.)
5620 </para>
5621
5622 <para>
5623 You construct values of types <literal>T1, MonadT, Swizzle</literal> by applying
5624 the constructor to suitable values, just as usual.  For example,
5625 </para>
5626
5627 <para>
5628
5629 <programlisting>
5630     a1 :: T Int
5631     a1 = T1 (\xy->x) 3
5632
5633     a2, a3 :: Swizzle
5634     a2 = MkSwizzle sort
5635     a3 = MkSwizzle reverse
5636
5637     a4 :: MonadT Maybe
5638     a4 = let r x = Just x
5639              b m k = case m of
5640                        Just y -> k y
5641                        Nothing -> Nothing
5642          in
5643          MkMonad r b
5644
5645     mkTs :: (forall b. b -> b -> b) -> a -> [T a]
5646     mkTs f x y = [T1 f x, T1 f y]
5647 </programlisting>
5648
5649 </para>
5650
5651 <para>
5652 The type of the argument can, as usual, be more general than the type
5653 required, as <literal>(MkSwizzle reverse)</literal> shows.  (<function>reverse</function>
5654 does not need the <literal>Ord</literal> constraint.)
5655 </para>
5656
5657 <para>
5658 When you use pattern matching, the bound variables may now have
5659 polymorphic types.  For example:
5660 </para>
5661
5662 <para>
5663
5664 <programlisting>
5665     f :: T a -> a -> (a, Char)
5666     f (T1 w k) x = (w k x, w 'c' 'd')
5667
5668     g :: (Ord a, Ord b) => Swizzle -> [a] -> (a -> b) -> [b]
5669     g (MkSwizzle s) xs f = s (map f (s xs))
5670
5671     h :: MonadT m -> [m a] -> m [a]
5672     h m [] = return m []
5673     h m (x:xs) = bind m x          $ \y ->
5674                  bind m (h m xs)   $ \ys ->
5675                  return m (y:ys)
5676 </programlisting>
5677
5678 </para>
5679
5680 <para>
5681 In the function <function>h</function> we use the record selectors <literal>return</literal>
5682 and <literal>bind</literal> to extract the polymorphic bind and return functions
5683 from the <literal>MonadT</literal> data structure, rather than using pattern
5684 matching.
5685 </para>
5686 </sect3>
5687
5688 <sect3>
5689 <title>Type inference</title>
5690
5691 <para>
5692 In general, type inference for arbitrary-rank types is undecidable.
5693 GHC uses an algorithm proposed by Odersky and Laufer ("Putting type annotations to work", POPL'96)
5694 to get a decidable algorithm by requiring some help from the programmer.
5695 We do not yet have a formal specification of "some help" but the rule is this:
5696 </para>
5697 <para>
5698 <emphasis>For a lambda-bound or case-bound variable, x, either the programmer
5699 provides an explicit polymorphic type for x, or GHC's type inference will assume
5700 that x's type has no foralls in it</emphasis>.
5701 </para>
5702 <para>
5703 What does it mean to "provide" an explicit type for x?  You can do that by
5704 giving a type signature for x directly, using a pattern type signature
5705 (<xref linkend="scoped-type-variables"/>), thus:
5706 <programlisting>
5707      \ f :: (forall a. a->a) -> (f True, f 'c')
5708 </programlisting>
5709 Alternatively, you can give a type signature to the enclosing
5710 context, which GHC can "push down" to find the type for the variable:
5711 <programlisting>
5712      (\ f -> (f True, f 'c')) :: (forall a. a->a) -> (Bool,Char)
5713 </programlisting>
5714 Here the type signature on the expression can be pushed inwards
5715 to give a type signature for f.  Similarly, and more commonly,
5716 one can give a type signature for the function itself:
5717 <programlisting>
5718      h :: (forall a. a->a) -> (Bool,Char)
5719      h f = (f True, f 'c')
5720 </programlisting>
5721 You don't need to give a type signature if the lambda bound variable
5722 is a constructor argument.  Here is an example we saw earlier:
5723 <programlisting>
5724     f :: T a -> a -> (a, Char)
5725     f (T1 w k) x = (w k x, w 'c' 'd')
5726 </programlisting>
5727 Here we do not need to give a type signature to <literal>w</literal>, because
5728 it is an argument of constructor <literal>T1</literal> and that tells GHC all
5729 it needs to know.
5730 </para>
5731
5732 </sect3>
5733
5734
5735 <sect3 id="implicit-quant">
5736 <title>Implicit quantification</title>
5737
5738 <para>
5739 GHC performs implicit quantification as follows.  <emphasis>At the top level (only) of
5740 user-written types, if and only if there is no explicit <literal>forall</literal>,
5741 GHC finds all the type variables mentioned in the type that are not already
5742 in scope, and universally quantifies them.</emphasis>  For example, the following pairs are
5743 equivalent:
5744 <programlisting>
5745   f :: a -> a
5746   f :: forall a. a -> a
5747
5748   g (x::a) = let
5749                 h :: a -> b -> b
5750                 h x y = y
5751              in ...
5752   g (x::a) = let
5753                 h :: forall b. a -> b -> b
5754                 h x y = y
5755              in ...
5756 </programlisting>
5757 </para>
5758 <para>
5759 Notice that GHC does <emphasis>not</emphasis> find the innermost possible quantification
5760 point.  For example:
5761 <programlisting>
5762   f :: (a -> a) -> Int
5763            -- MEANS
5764   f :: forall a. (a -> a) -> Int
5765            -- NOT
5766   f :: (forall a. a -> a) -> Int
5767
5768
5769   g :: (Ord a => a -> a) -> Int
5770            -- MEANS the illegal type
5771   g :: forall a. (Ord a => a -> a) -> Int
5772            -- NOT
5773   g :: (forall a. Ord a => a -> a) -> Int
5774 </programlisting>
5775 The latter produces an illegal type, which you might think is silly,
5776 but at least the rule is simple.  If you want the latter type, you
5777 can write your for-alls explicitly.  Indeed, doing so is strongly advised
5778 for rank-2 types.
5779 </para>
5780 </sect3>
5781 </sect2>
5782
5783
5784 <sect2 id="impredicative-polymorphism">
5785 <title>Impredicative polymorphism
5786 </title>
5787 <para><emphasis>NOTE: the impredicative-polymorphism feature is deprecated in GHC 6.12, and
5788 will be removed or replaced in GHC 6.14.</emphasis></para>
5789
5790 <para>GHC supports <emphasis>impredicative polymorphism</emphasis>,
5791 enabled with <option>-XImpredicativeTypes</option>.
5792 This means
5793 that you can call a polymorphic function at a polymorphic type, and
5794 parameterise data structures over polymorphic types.  For example:
5795 <programlisting>
5796   f :: Maybe (forall a. [a] -> [a]) -> Maybe ([Int], [Char])
5797   f (Just g) = Just (g [3], g "hello")
5798   f Nothing  = Nothing
5799 </programlisting>
5800 Notice here that the <literal>Maybe</literal> type is parameterised by the
5801 <emphasis>polymorphic</emphasis> type <literal>(forall a. [a] ->
5802 [a])</literal>.
5803 </para>
5804 <para>The technical details of this extension are described in the paper
5805 <ulink url="http://research.microsoft.com/%7Esimonpj/papers/boxy/">Boxy types:
5806 type inference for higher-rank types and impredicativity</ulink>,
5807 which appeared at ICFP 2006.
5808 </para>
5809 </sect2>
5810
5811 <sect2 id="scoped-type-variables">
5812 <title>Lexically scoped type variables
5813 </title>
5814
5815 <para>
5816 GHC supports <emphasis>lexically scoped type variables</emphasis>, without
5817 which some type signatures are simply impossible to write. For example:
5818 <programlisting>
5819 f :: forall a. [a] -> [a]
5820 f xs = ys ++ ys
5821      where
5822        ys :: [a]
5823        ys = reverse xs
5824 </programlisting>
5825 The type signature for <literal>f</literal> brings the type variable <literal>a</literal> into scope,
5826 because of the explicit <literal>forall</literal> (<xref linkend="decl-type-sigs"/>).
5827 The type variables bound by a <literal>forall</literal> scope over
5828 the entire definition of the accompanying value declaration.
5829 In this example, the type variable <literal>a</literal> scopes over the whole
5830 definition of <literal>f</literal>, including over
5831 the type signature for <varname>ys</varname>.
5832 In Haskell 98 it is not possible to declare
5833 a type for <varname>ys</varname>; a major benefit of scoped type variables is that
5834 it becomes possible to do so.
5835 </para>
5836 <para>Lexically-scoped type variables are enabled by
5837 <option>-XScopedTypeVariables</option>.  This flag implies <option>-XRelaxedPolyRec</option>.
5838 </para>
5839 <para>Note: GHC 6.6 contains substantial changes to the way that scoped type
5840 variables work, compared to earlier releases.  Read this section
5841 carefully!</para>
5842
5843 <sect3>
5844 <title>Overview</title>
5845
5846 <para>The design follows the following principles
5847 <itemizedlist>
5848 <listitem><para>A scoped type variable stands for a type <emphasis>variable</emphasis>, and not for
5849 a <emphasis>type</emphasis>. (This is a change from GHC's earlier
5850 design.)</para></listitem>
5851 <listitem><para>Furthermore, distinct lexical type variables stand for distinct
5852 type variables.  This means that every programmer-written type signature
5853 (including one that contains free scoped type variables) denotes a
5854 <emphasis>rigid</emphasis> type; that is, the type is fully known to the type
5855 checker, and no inference is involved.</para></listitem>
5856 <listitem><para>Lexical type variables may be alpha-renamed freely, without
5857 changing the program.</para></listitem>
5858 </itemizedlist>
5859 </para>
5860 <para>
5861 A <emphasis>lexically scoped type variable</emphasis> can be bound by:
5862 <itemizedlist>
5863 <listitem><para>A declaration type signature (<xref linkend="decl-type-sigs"/>)</para></listitem>
5864 <listitem><para>An expression type signature (<xref linkend="exp-type-sigs"/>)</para></listitem>
5865 <listitem><para>A pattern type signature (<xref linkend="pattern-type-sigs"/>)</para></listitem>
5866 <listitem><para>Class and instance declarations (<xref linkend="cls-inst-scoped-tyvars"/>)</para></listitem>
5867 </itemizedlist>
5868 </para>
5869 <para>
5870 In Haskell, a programmer-written type signature is implicitly quantified over
5871 its free type variables (<ulink
5872 url="http://www.haskell.org/onlinereport/decls.html#sect4.1.2">Section
5873 4.1.2</ulink>
5874 of the Haskell Report).
5875 Lexically scoped type variables affect this implicit quantification rules
5876 as follows: any type variable that is in scope is <emphasis>not</emphasis> universally
5877 quantified. For example, if type variable <literal>a</literal> is in scope,
5878 then
5879 <programlisting>
5880   (e :: a -> a)     means     (e :: a -> a)
5881   (e :: b -> b)     means     (e :: forall b. b->b)
5882   (e :: a -> b)     means     (e :: forall b. a->b)
5883 </programlisting>
5884 </para>
5885
5886
5887 </sect3>
5888
5889
5890 <sect3 id="decl-type-sigs">
5891 <title>Declaration type signatures</title>
5892 <para>A declaration type signature that has <emphasis>explicit</emphasis>
5893 quantification (using <literal>forall</literal>) brings into scope the
5894 explicitly-quantified
5895 type variables, in the definition of the named function.  For example:
5896 <programlisting>
5897   f :: forall a. [a] -> [a]
5898   f (x:xs) = xs ++ [ x :: a ]
5899 </programlisting>
5900 The "<literal>forall a</literal>" brings "<literal>a</literal>" into scope in
5901 the definition of "<literal>f</literal>".
5902 </para>
5903 <para>This only happens if:
5904 <itemizedlist>
5905 <listitem><para> The quantification in <literal>f</literal>'s type
5906 signature is explicit.  For example:
5907 <programlisting>
5908   g :: [a] -> [a]
5909   g (x:xs) = xs ++ [ x :: a ]
5910 </programlisting>
5911 This program will be rejected, because "<literal>a</literal>" does not scope
5912 over the definition of "<literal>f</literal>", so "<literal>x::a</literal>"
5913 means "<literal>x::forall a. a</literal>" by Haskell's usual implicit
5914 quantification rules.
5915 </para></listitem>
5916 <listitem><para> The signature gives a type for a function binding or a bare variable binding,
5917 not a pattern binding.
5918 For example:
5919 <programlisting>
5920   f1 :: forall a. [a] -> [a]
5921   f1 (x:xs) = xs ++ [ x :: a ]   -- OK
5922
5923   f2 :: forall a. [a] -> [a]
5924   f2 = \(x:xs) -> xs ++ [ x :: a ]   -- OK
5925
5926   f3 :: forall a. [a] -> [a]
5927   Just f3 = Just (\(x:xs) -> xs ++ [ x :: a ])   -- Not OK!
5928 </programlisting>
5929 The binding for <literal>f3</literal> is a pattern binding, and so its type signature
5930 does not bring <literal>a</literal> into scope.   However <literal>f1</literal> is a
5931 function binding, and <literal>f2</literal> binds a bare variable; in both cases
5932 the type signature brings <literal>a</literal> into scope.
5933 </para></listitem>
5934 </itemizedlist>
5935 </para>
5936 </sect3>
5937
5938 <sect3 id="exp-type-sigs">
5939 <title>Expression type signatures</title>
5940
5941 <para>An expression type signature that has <emphasis>explicit</emphasis>
5942 quantification (using <literal>forall</literal>) brings into scope the
5943 explicitly-quantified
5944 type variables, in the annotated expression.  For example:
5945 <programlisting>
5946   f = runST ( (op >>= \(x :: STRef s Int) -> g x) :: forall s. ST s Bool )
5947 </programlisting>
5948 Here, the type signature <literal>forall a. ST s Bool</literal> brings the
5949 type variable <literal>s</literal> into scope, in the annotated expression
5950 <literal>(op >>= \(x :: STRef s Int) -> g x)</literal>.
5951 </para>
5952
5953 </sect3>
5954
5955 <sect3 id="pattern-type-sigs">
5956 <title>Pattern type signatures</title>
5957 <para>
5958 A type signature may occur in any pattern; this is a <emphasis>pattern type
5959 signature</emphasis>.
5960 For example:
5961 <programlisting>
5962   -- f and g assume that 'a' is already in scope
5963   f = \(x::Int, y::a) -> x
5964   g (x::a) = x
5965   h ((x,y) :: (Int,Bool)) = (y,x)
5966 </programlisting>
5967 In the case where all the type variables in the pattern type signature are
5968 already in scope (i.e. bound by the enclosing context), matters are simple: the
5969 signature simply constrains the type of the pattern in the obvious way.
5970 </para>
5971 <para>
5972 Unlike expression and declaration type signatures, pattern type signatures are not implicitly generalised.
5973 The pattern in a <emphasis>pattern binding</emphasis> may only mention type variables
5974 that are already in scope.  For example:
5975 <programlisting>
5976   f :: forall a. [a] -> (Int, [a])
5977   f xs = (n, zs)
5978     where
5979       (ys::[a], n) = (reverse xs, length xs) -- OK
5980       zs::[a] = xs ++ ys                     -- OK
5981
5982       Just (v::b) = ...  -- Not OK; b is not in scope
5983 </programlisting>
5984 Here, the pattern signatures for <literal>ys</literal> and <literal>zs</literal>
5985 are fine, but the one for <literal>v</literal> is not because <literal>b</literal> is
5986 not in scope.
5987 </para>
5988 <para>
5989 However, in all patterns <emphasis>other</emphasis> than pattern bindings, a pattern
5990 type signature may mention a type variable that is not in scope; in this case,
5991 <emphasis>the signature brings that type variable into scope</emphasis>.
5992 This is particularly important for existential data constructors.  For example:
5993 <programlisting>
5994   data T = forall a. MkT [a]
5995
5996   k :: T -> T
5997   k (MkT [t::a]) = MkT t3
5998                  where
5999                    t3::[a] = [t,t,t]
6000 </programlisting>
6001 Here, the pattern type signature <literal>(t::a)</literal> mentions a lexical type
6002 variable that is not already in scope.  Indeed, it <emphasis>cannot</emphasis> already be in scope,
6003 because it is bound by the pattern match.  GHC's rule is that in this situation
6004 (and only then), a pattern type signature can mention a type variable that is
6005 not already in scope; the effect is to bring it into scope, standing for the
6006 existentially-bound type variable.
6007 </para>
6008 <para>
6009 When a pattern type signature binds a type variable in this way, GHC insists that the
6010 type variable is bound to a <emphasis>rigid</emphasis>, or fully-known, type variable.
6011 This means that any user-written type signature always stands for a completely known type.
6012 </para>
6013 <para>
6014 If all this seems a little odd, we think so too.  But we must have
6015 <emphasis>some</emphasis> way to bring such type variables into scope, else we
6016 could not name existentially-bound type variables in subsequent type signatures.
6017 </para>
6018 <para>
6019 This is (now) the <emphasis>only</emphasis> situation in which a pattern type
6020 signature is allowed to mention a lexical variable that is not already in
6021 scope.
6022 For example, both <literal>f</literal> and <literal>g</literal> would be
6023 illegal if <literal>a</literal> was not already in scope.
6024 </para>
6025
6026
6027 </sect3>
6028
6029 <!-- ==================== Commented out part about result type signatures
6030
6031 <sect3 id="result-type-sigs">
6032 <title>Result type signatures</title>
6033
6034 <para>
6035 The result type of a function, lambda, or case expression alternative can be given a signature, thus:
6036
6037 <programlisting>
6038   {- f assumes that 'a' is already in scope -}
6039   f x y :: [a] = [x,y,x]
6040
6041   g = \ x :: [Int] -> [3,4]
6042
6043   h :: forall a. [a] -> a
6044   h xs = case xs of
6045             (y:ys) :: a -> y
6046 </programlisting>
6047 The final <literal>:: [a]</literal> after the patterns of <literal>f</literal> gives the type of
6048 the result of the function.  Similarly, the body of the lambda in the RHS of
6049 <literal>g</literal> is <literal>[Int]</literal>, and the RHS of the case
6050 alternative in <literal>h</literal> is <literal>a</literal>.
6051 </para>
6052 <para> A result type signature never brings new type variables into scope.</para>
6053 <para>
6054 There are a couple of syntactic wrinkles.  First, notice that all three
6055 examples would parse quite differently with parentheses:
6056 <programlisting>
6057   {- f assumes that 'a' is already in scope -}
6058   f x (y :: [a]) = [x,y,x]
6059
6060   g = \ (x :: [Int]) -> [3,4]
6061
6062   h :: forall a. [a] -> a
6063   h xs = case xs of
6064             ((y:ys) :: a) -> y
6065 </programlisting>
6066 Now the signature is on the <emphasis>pattern</emphasis>; and
6067 <literal>h</literal> would certainly be ill-typed (since the pattern
6068 <literal>(y:ys)</literal> cannot have the type <literal>a</literal>.
6069
6070 Second, to avoid ambiguity, the type after the &ldquo;<literal>::</literal>&rdquo; in a result
6071 pattern signature on a lambda or <literal>case</literal> must be atomic (i.e. a single
6072 token or a parenthesised type of some sort).  To see why,
6073 consider how one would parse this:
6074 <programlisting>
6075   \ x :: a -> b -> x
6076 </programlisting>
6077 </para>
6078 </sect3>
6079
6080  -->
6081
6082 <sect3 id="cls-inst-scoped-tyvars">
6083 <title>Class and instance declarations</title>
6084 <para>
6085
6086 The type variables in the head of a <literal>class</literal> or <literal>instance</literal> declaration
6087 scope over the methods defined in the <literal>where</literal> part.  For example:
6088
6089
6090 <programlisting>
6091   class C a where
6092     op :: [a] -> a
6093
6094     op xs = let ys::[a]
6095                 ys = reverse xs
6096             in
6097             head ys
6098 </programlisting>
6099 </para>
6100 </sect3>
6101
6102 </sect2>
6103
6104
6105 <sect2 id="typing-binds">
6106 <title>Generalised typing of mutually recursive bindings</title>
6107
6108 <para>
6109 The Haskell Report specifies that a group of bindings (at top level, or in a
6110 <literal>let</literal> or <literal>where</literal>) should be sorted into
6111 strongly-connected components, and then type-checked in dependency order
6112 (<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.1">Haskell
6113 Report, Section 4.5.1</ulink>).
6114 As each group is type-checked, any binders of the group that
6115 have
6116 an explicit type signature are put in the type environment with the specified
6117 polymorphic type,
6118 and all others are monomorphic until the group is generalised
6119 (<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.2">Haskell Report, Section 4.5.2</ulink>).
6120 </para>
6121
6122 <para>Following a suggestion of Mark Jones, in his paper
6123 <ulink url="http://citeseer.ist.psu.edu/424440.html">Typing Haskell in
6124 Haskell</ulink>,
6125 GHC implements a more general scheme.  If <option>-XRelaxedPolyRec</option> is
6126 specified:
6127 <emphasis>the dependency analysis ignores references to variables that have an explicit
6128 type signature</emphasis>.
6129 As a result of this refined dependency analysis, the dependency groups are smaller, and more bindings will
6130 typecheck.  For example, consider:
6131 <programlisting>
6132   f :: Eq a =&gt; a -> Bool
6133   f x = (x == x) || g True || g "Yes"
6134
6135   g y = (y &lt;= y) || f True
6136 </programlisting>
6137 This is rejected by Haskell 98, but under Jones's scheme the definition for
6138 <literal>g</literal> is typechecked first, separately from that for
6139 <literal>f</literal>,
6140 because the reference to <literal>f</literal> in <literal>g</literal>'s right
6141 hand side is ignored by the dependency analysis.  Then <literal>g</literal>'s
6142 type is generalised, to get
6143 <programlisting>
6144   g :: Ord a =&gt; a -> Bool
6145 </programlisting>
6146 Now, the definition for <literal>f</literal> is typechecked, with this type for
6147 <literal>g</literal> in the type environment.
6148 </para>
6149
6150 <para>
6151 The same refined dependency analysis also allows the type signatures of
6152 mutually-recursive functions to have different contexts, something that is illegal in
6153 Haskell 98 (Section 4.5.2, last sentence).  With
6154 <option>-XRelaxedPolyRec</option>
6155 GHC only insists that the type signatures of a <emphasis>refined</emphasis> group have identical
6156 type signatures; in practice this means that only variables bound by the same
6157 pattern binding must have the same context.  For example, this is fine:
6158 <programlisting>
6159   f :: Eq a =&gt; a -> Bool
6160   f x = (x == x) || g True
6161
6162   g :: Ord a =&gt; a -> Bool
6163   g y = (y &lt;= y) || f True
6164 </programlisting>
6165 </para>
6166 </sect2>
6167
6168 <sect2 id="mono-local-binds">
6169 <title>Monomorphic local bindings</title>
6170 <para>
6171 We are actively thinking of simplifying GHC's type system, by <emphasis>not generalising local bindings</emphasis>.
6172 The rationale is described in the paper
6173 <ulink url="http://research.microsoft.com/~simonpj/papers/constraints/index.htm">Let should not be generalised</ulink>.
6174 </para>
6175 <para>
6176 The experimental new behaviour is enabled by the flag <option>-XMonoLocalBinds</option>.  The effect is
6177 that local (that is, non-top-level) bindings without a type signature are not generalised at all.  You can
6178 think of it as an extreme (but much more predictable) version of the Monomorphism Restriction.
6179 If you supply a type signature, then the flag has no effect.
6180 </para>
6181 </sect2>
6182
6183 </sect1>
6184 <!-- ==================== End of type system extensions =================  -->
6185
6186 <!-- ====================== TEMPLATE HASKELL =======================  -->
6187
6188 <sect1 id="template-haskell">
6189 <title>Template Haskell</title>
6190
6191 <para>Template Haskell allows you to do compile-time meta-programming in
6192 Haskell.
6193 The background to
6194 the main technical innovations is discussed in "<ulink
6195 url="http://research.microsoft.com/~simonpj/papers/meta-haskell/">
6196 Template Meta-programming for Haskell</ulink>" (Proc Haskell Workshop 2002).
6197 </para>
6198 <para>
6199 There is a Wiki page about
6200 Template Haskell at <ulink url="http://www.haskell.org/haskellwiki/Template_Haskell">
6201 http://www.haskell.org/haskellwiki/Template_Haskell</ulink>, and that is the best place to look for
6202 further details.
6203 You may also
6204 consult the <ulink
6205 url="http://www.haskell.org/ghc/docs/latest/html/libraries/index.html">online
6206 Haskell library reference material</ulink>
6207 (look for module <literal>Language.Haskell.TH</literal>).
6208 Many changes to the original design are described in
6209       <ulink url="http://research.microsoft.com/~simonpj/papers/meta-haskell/notes2.ps">
6210 Notes on Template Haskell version 2</ulink>.
6211 Not all of these changes are in GHC, however.
6212 </para>
6213
6214 <para> The first example from that paper is set out below (<xref linkend="th-example"/>)
6215 as a worked example to help get you started.
6216 </para>
6217
6218 <para>
6219 The documentation here describes the realisation of Template Haskell in GHC.  It is not detailed enough to
6220 understand Template Haskell; see the <ulink url="http://haskell.org/haskellwiki/Template_Haskell">
6221 Wiki page</ulink>.
6222 </para>
6223
6224     <sect2>
6225       <title>Syntax</title>
6226
6227       <para> Template Haskell has the following new syntactic
6228       constructions.  You need to use the flag
6229       <option>-XTemplateHaskell</option>
6230         <indexterm><primary><option>-XTemplateHaskell</option></primary>
6231       </indexterm>to switch these syntactic extensions on
6232       (<option>-XTemplateHaskell</option> is no longer implied by
6233       <option>-fglasgow-exts</option>).</para>
6234
6235         <itemizedlist>
6236               <listitem><para>
6237                   A splice is written <literal>$x</literal>, where <literal>x</literal> is an
6238                   identifier, or <literal>$(...)</literal>, where the "..." is an arbitrary expression.
6239                   There must be no space between the "$" and the identifier or parenthesis.  This use
6240                   of "$" overrides its meaning as an infix operator, just as "M.x" overrides the meaning
6241                   of "." as an infix operator.  If you want the infix operator, put spaces around it.
6242                   </para>
6243               <para> A splice can occur in place of
6244                   <itemizedlist>
6245                     <listitem><para> an expression; the spliced expression must
6246                     have type <literal>Q Exp</literal></para></listitem>
6247                     <listitem><para> an type; the spliced expression must
6248                     have type <literal>Q Typ</literal></para></listitem>
6249                     <listitem><para> a list of top-level declarations; the spliced expression
6250                     must have type <literal>Q [Dec]</literal></para></listitem>
6251                     </itemizedlist>
6252             Note that pattern splices are not supported.
6253             Inside a splice you can can only call functions defined in imported modules,
6254             not functions defined elsewhere in the same module.</para></listitem>
6255
6256               <listitem><para>
6257                   A expression quotation is written in Oxford brackets, thus:
6258                   <itemizedlist>
6259                     <listitem><para> <literal>[| ... |]</literal>, or <literal>[e| ... |]</literal>,
6260                              where the "..." is an expression;
6261                              the quotation has type <literal>Q Exp</literal>.</para></listitem>
6262                     <listitem><para> <literal>[d| ... |]</literal>, where the "..." is a list of top-level declarations;
6263                              the quotation has type <literal>Q [Dec]</literal>.</para></listitem>
6264                     <listitem><para> <literal>[t| ... |]</literal>, where the "..." is a type;
6265                              the quotation has type <literal>Q Type</literal>.</para></listitem>
6266                     <listitem><para> <literal>[p| ... |]</literal>, where the "..." is a pattern;
6267                              the quotation has type <literal>Q Pat</literal>.</para></listitem>
6268                   </itemizedlist></para></listitem>
6269
6270               <listitem><para>
6271                   A quasi-quotation can appear in either a pattern context or an
6272                   expression context and is also written in Oxford brackets:
6273                   <itemizedlist>
6274                     <listitem><para> <literal>[<replaceable>varid</replaceable>| ... |]</literal>,
6275                         where the "..." is an arbitrary string; a full description of the
6276                         quasi-quotation facility is given in <xref linkend="th-quasiquotation"/>.</para></listitem>
6277                   </itemizedlist></para></listitem>
6278
6279               <listitem><para>
6280                   A name can be quoted with either one or two prefix single quotes:
6281                   <itemizedlist>
6282                     <listitem><para> <literal>'f</literal> has type <literal>Name</literal>, and names the function <literal>f</literal>.
6283                   Similarly <literal>'C</literal> has type <literal>Name</literal> and names the data constructor <literal>C</literal>.
6284                   In general <literal>'</literal><replaceable>thing</replaceable> interprets <replaceable>thing</replaceable> in an expression context.
6285                      </para></listitem>
6286                     <listitem><para> <literal>''T</literal> has type <literal>Name</literal>, and names the type constructor  <literal>T</literal>.
6287                   That is, <literal>''</literal><replaceable>thing</replaceable> interprets <replaceable>thing</replaceable> in a type context.
6288                      </para></listitem>
6289                   </itemizedlist>
6290                   These <literal>Names</literal> can be used to construct Template Haskell expressions, patterns, declarations etc.  They
6291                   may also be given as an argument to the <literal>reify</literal> function.
6292                  </para>
6293                 </listitem>
6294
6295               <listitem><para> You may omit the <literal>$(...)</literal> in a top-level declaration splice.
6296               Simply writing an expression (rather than a declaration) implies a splice.  For example, you can write
6297 <programlisting>
6298 module Foo where
6299 import Bar
6300
6301 f x = x
6302
6303 $(deriveStuff 'f)   -- Uses the $(...) notation
6304
6305 g y = y+1
6306
6307 deriveStuff 'g      -- Omits the $(...)
6308
6309 h z = z-1
6310 </programlisting>
6311             This abbreviation makes top-level declaration slices quieter and less intimidating.
6312             </para></listitem>
6313
6314
6315         </itemizedlist>
6316 (Compared to the original paper, there are many differences of detail.
6317 The syntax for a declaration splice uses "<literal>$</literal>" not "<literal>splice</literal>".
6318 The type of the enclosed expression must be  <literal>Q [Dec]</literal>, not  <literal>[Q Dec]</literal>.
6319 Pattern splices and quotations are not implemented.)
6320
6321 </sect2>
6322
6323 <sect2>  <title> Using Template Haskell </title>
6324 <para>
6325 <itemizedlist>
6326     <listitem><para>
6327     The data types and monadic constructor functions for Template Haskell are in the library
6328     <literal>Language.Haskell.THSyntax</literal>.
6329     </para></listitem>
6330
6331     <listitem><para>
6332     You can only run a function at compile time if it is imported from another module.  That is,
6333             you can't define a function in a module, and call it from within a splice in the same module.
6334             (It would make sense to do so, but it's hard to implement.)
6335    </para></listitem>
6336
6337    <listitem><para>
6338    You can only run a function at compile time if it is imported
6339    from another module <emphasis>that is not part of a mutually-recursive group of modules
6340    that includes the module currently being compiled</emphasis>.  Furthermore, all of the modules of
6341    the mutually-recursive group must be reachable by non-SOURCE imports from the module where the
6342    splice is to be run.</para>
6343    <para>
6344    For example, when compiling module A,
6345    you can only run Template Haskell functions imported from B if B does not import A (directly or indirectly).
6346    The reason should be clear: to run B we must compile and run A, but we are currently type-checking A.
6347    </para></listitem>
6348
6349     <listitem><para>
6350             The flag <literal>-ddump-splices</literal> shows the expansion of all top-level splices as they happen.
6351    </para></listitem>
6352     <listitem><para>
6353             If you are building GHC from source, you need at least a stage-2 bootstrap compiler to
6354               run Template Haskell.  A stage-1 compiler will reject the TH constructs.  Reason: TH
6355               compiles and runs a program, and then looks at the result.  So it's important that
6356               the program it compiles produces results whose representations are identical to
6357               those of the compiler itself.
6358    </para></listitem>
6359 </itemizedlist>
6360 </para>
6361 <para> Template Haskell works in any mode (<literal>--make</literal>, <literal>--interactive</literal>,
6362         or file-at-a-time).  There used to be a restriction to the former two, but that restriction
6363         has been lifted.
6364 </para>
6365 </sect2>
6366
6367 <sect2 id="th-example">  <title> A Template Haskell Worked Example </title>
6368 <para>To help you get over the confidence barrier, try out this skeletal worked example.
6369   First cut and paste the two modules below into "Main.hs" and "Printf.hs":</para>
6370
6371 <programlisting>
6372
6373 {- Main.hs -}
6374 module Main where
6375
6376 -- Import our template "pr"
6377 import Printf ( pr )
6378
6379 -- The splice operator $ takes the Haskell source code
6380 -- generated at compile time by "pr" and splices it into
6381 -- the argument of "putStrLn".
6382 main = putStrLn ( $(pr "Hello") )
6383
6384
6385 {- Printf.hs -}
6386 module Printf where
6387
6388 -- Skeletal printf from the paper.
6389 -- It needs to be in a separate module to the one where
6390 -- you intend to use it.
6391
6392 -- Import some Template Haskell syntax
6393 import Language.Haskell.TH
6394
6395 -- Describe a format string
6396 data Format = D | S | L String
6397
6398 -- Parse a format string.  This is left largely to you
6399 -- as we are here interested in building our first ever
6400 -- Template Haskell program and not in building printf.
6401 parse :: String -> [Format]
6402 parse s   = [ L s ]
6403
6404 -- Generate Haskell source code from a parsed representation
6405 -- of the format string.  This code will be spliced into
6406 -- the module which calls "pr", at compile time.
6407 gen :: [Format] -> Q Exp
6408 gen [D]   = [| \n -> show n |]
6409 gen [S]   = [| \s -> s |]
6410 gen [L s] = stringE s
6411
6412 -- Here we generate the Haskell code for the splice
6413 -- from an input format string.
6414 pr :: String -> Q Exp
6415 pr s = gen (parse s)
6416 </programlisting>
6417
6418 <para>Now run the compiler (here we are a Cygwin prompt on Windows):
6419 </para>
6420 <programlisting>
6421 $ ghc --make -XTemplateHaskell main.hs -o main.exe
6422 </programlisting>
6423
6424 <para>Run "main.exe" and here is your output:</para>
6425
6426 <programlisting>
6427 $ ./main
6428 Hello
6429 </programlisting>
6430
6431 </sect2>
6432
6433 <sect2>
6434 <title>Using Template Haskell with Profiling</title>
6435 <indexterm><primary>profiling</primary><secondary>with Template Haskell</secondary></indexterm>
6436
6437 <para>Template Haskell relies on GHC's built-in bytecode compiler and
6438 interpreter to run the splice expressions.  The bytecode interpreter
6439 runs the compiled expression on top of the same runtime on which GHC
6440 itself is running; this means that the compiled code referred to by
6441 the interpreted expression must be compatible with this runtime, and
6442 in particular this means that object code that is compiled for
6443 profiling <emphasis>cannot</emphasis> be loaded and used by a splice
6444 expression, because profiled object code is only compatible with the
6445 profiling version of the runtime.</para>
6446
6447 <para>This causes difficulties if you have a multi-module program
6448 containing Template Haskell code and you need to compile it for
6449 profiling, because GHC cannot load the profiled object code and use it
6450 when executing the splices.  Fortunately GHC provides a workaround.
6451 The basic idea is to compile the program twice:</para>
6452
6453 <orderedlist>
6454 <listitem>
6455   <para>Compile the program or library first the normal way, without
6456   <option>-prof</option><indexterm><primary><option>-prof</option></primary></indexterm>.</para>
6457 </listitem>
6458 <listitem>
6459   <para>Then compile it again with <option>-prof</option>, and
6460   additionally use <option>-osuf
6461   p_o</option><indexterm><primary><option>-osuf</option></primary></indexterm>
6462   to name the object files differently (you can choose any suffix
6463   that isn't the normal object suffix here).  GHC will automatically
6464   load the object files built in the first step when executing splice
6465   expressions.  If you omit the <option>-osuf</option> flag when
6466   building with <option>-prof</option> and Template Haskell is used,
6467   GHC will emit an error message. </para>
6468 </listitem>
6469 </orderedlist>
6470 </sect2>
6471
6472 <sect2 id="th-quasiquotation">  <title> Template Haskell Quasi-quotation </title>
6473 <para>Quasi-quotation allows patterns and expressions to be written using
6474 programmer-defined concrete syntax; the motivation behind the extension and
6475 several examples are documented in
6476 "<ulink url="http://www.eecs.harvard.edu/~mainland/ghc-quasiquoting/">Why It's
6477 Nice to be Quoted: Quasiquoting for Haskell</ulink>" (Proc Haskell Workshop
6478 2007). The example below shows how to write a quasiquoter for a simple
6479 expression language.</para>
6480 <para>
6481 Here are the salient features
6482 <itemizedlist>
6483 <listitem><para>
6484 A quasi-quote has the form
6485 <literal>[<replaceable>quoter</replaceable>| <replaceable>string</replaceable> |]</literal>.
6486 <itemizedlist>
6487 <listitem><para>
6488 The <replaceable>quoter</replaceable> must be the (unqualified) name of an imported
6489 quoter; it cannot be an arbitrary expression.
6490 </para></listitem>
6491 <listitem><para>
6492 The <replaceable>quoter</replaceable> cannot be "<literal>e</literal>",
6493 "<literal>t</literal>", "<literal>d</literal>", or "<literal>p</literal>", since
6494 those overlap with Template Haskell quotations.
6495 </para></listitem>
6496 <listitem><para>
6497 There must be no spaces in the token
6498 <literal>[<replaceable>quoter</replaceable>|</literal>.
6499 </para></listitem>
6500 <listitem><para>
6501 The quoted <replaceable>string</replaceable>
6502 can be arbitrary, and may contain newlines.
6503 </para></listitem>
6504 </itemizedlist>
6505 </para></listitem>
6506
6507 <listitem><para>
6508 A quasiquote may appear in place of
6509 <itemizedlist>
6510 <listitem><para>An expression</para></listitem>
6511 <listitem><para>A pattern</para></listitem>
6512 <listitem><para>A type</para></listitem>
6513 <listitem><para>A top-level declaration</para></listitem>
6514 </itemizedlist>
6515 (Only the first two are described in the paper.)
6516 </para></listitem>
6517
6518 <listitem><para>
6519 A quoter is a value of type <literal>Language.Haskell.TH.Quote.QuasiQuoter</literal>,
6520 which is defined thus:
6521 <programlisting>
6522 data QuasiQuoter = QuasiQuoter { quoteExp  :: String -> Q Exp,
6523                                  quotePat  :: String -> Q Pat,
6524                                  quoteType :: String -> Q Type,
6525                                  quoteDec  :: String -> Q [Dec] }
6526 </programlisting>
6527 That is, a quoter is a tuple of four parsers, one for each of the contexts
6528 in which a quasi-quote can occur.
6529 </para></listitem>
6530 <listitem><para>
6531 A quasi-quote is expanded by applying the appropriate parser to the string
6532 enclosed by the Oxford brackets.  The context of the quasi-quote (expression, pattern,
6533 type, declaration) determines which of the parsers is called.
6534 </para></listitem>
6535 </itemizedlist>
6536 </para>
6537 <para>
6538 The example below shows quasi-quotation in action.  The quoter <literal>expr</literal>
6539 is bound to a value of type <literal>QuasiQuoter</literal> defined in module <literal>Expr</literal>.
6540 The example makes use of an antiquoted
6541 variable <literal>n</literal>, indicated by the syntax <literal>'int:n</literal>
6542 (this syntax for anti-quotation was defined by the parser's
6543 author, <emphasis>not</emphasis> by GHC). This binds <literal>n</literal> to the
6544 integer value argument of the constructor <literal>IntExpr</literal> when
6545 pattern matching. Please see the referenced paper for further details regarding
6546 anti-quotation as well as the description of a technique that uses SYB to
6547 leverage a single parser of type <literal>String -> a</literal> to generate both
6548 an expression parser that returns a value of type <literal>Q Exp</literal> and a
6549 pattern parser that returns a value of type <literal>Q Pat</literal>.
6550 </para>
6551
6552 <para>
6553 Quasiquoters must obey the same stage restrictions as Template Haskell, e.g., in
6554 the example, <literal>expr</literal> cannot be defined
6555 in <literal>Main.hs</literal> where it is used, but must be imported.
6556 </para>
6557
6558 <programlisting>
6559 {- ------------- file Main.hs --------------- -}
6560 module Main where
6561
6562 import Expr
6563
6564 main :: IO ()
6565 main = do { print $ eval [expr|1 + 2|]
6566           ; case IntExpr 1 of
6567               { [expr|'int:n|] -> print n
6568               ;  _              -> return ()
6569               }
6570           }
6571
6572
6573 {- ------------- file Expr.hs --------------- -}
6574 module Expr where
6575
6576 import qualified Language.Haskell.TH as TH
6577 import Language.Haskell.TH.Quote
6578
6579 data Expr  =  IntExpr Integer
6580            |  AntiIntExpr String
6581            |  BinopExpr BinOp Expr Expr
6582            |  AntiExpr String
6583     deriving(Show, Typeable, Data)
6584
6585 data BinOp  =  AddOp
6586             |  SubOp
6587             |  MulOp
6588             |  DivOp
6589     deriving(Show, Typeable, Data)
6590
6591 eval :: Expr -> Integer
6592 eval (IntExpr n)        = n
6593 eval (BinopExpr op x y) = (opToFun op) (eval x) (eval y)
6594   where
6595     opToFun AddOp = (+)
6596     opToFun SubOp = (-)
6597     opToFun MulOp = (*)
6598     opToFun DivOp = div
6599
6600 expr = QuasiQuoter { quoteExp = parseExprExp, quotePat =  parseExprPat }
6601
6602 -- Parse an Expr, returning its representation as
6603 -- either a Q Exp or a Q Pat. See the referenced paper
6604 -- for how to use SYB to do this by writing a single
6605 -- parser of type String -> Expr instead of two
6606 -- separate parsers.
6607
6608 parseExprExp :: String -> Q Exp
6609 parseExprExp ...
6610
6611 parseExprPat :: String -> Q Pat
6612 parseExprPat ...
6613 </programlisting>
6614
6615 <para>Now run the compiler:
6616 <programlisting>
6617 $ ghc --make -XQuasiQuotes Main.hs -o main
6618 </programlisting>
6619 </para>
6620
6621 <para>Run "main" and here is your output:
6622 <programlisting>
6623 $ ./main
6624 3
6625 1
6626 </programlisting>
6627 </para>
6628 </sect2>
6629
6630 </sect1>
6631
6632 <!-- ===================== Arrow notation ===================  -->
6633
6634 <sect1 id="arrow-notation">
6635 <title>Arrow notation
6636 </title>
6637
6638 <para>Arrows are a generalization of monads introduced by John Hughes.
6639 For more details, see
6640 <itemizedlist>
6641
6642 <listitem>
6643 <para>
6644 &ldquo;Generalising Monads to Arrows&rdquo;,
6645 John Hughes, in <citetitle>Science of Computer Programming</citetitle> 37,
6646 pp67&ndash;111, May 2000.
6647 The paper that introduced arrows: a friendly introduction, motivated with
6648 programming examples.
6649 </para>
6650 </listitem>
6651
6652 <listitem>
6653 <para>
6654 &ldquo;<ulink url="http://www.soi.city.ac.uk/~ross/papers/notation.html">A New Notation for Arrows</ulink>&rdquo;,
6655 Ross Paterson, in <citetitle>ICFP</citetitle>, Sep 2001.
6656 Introduced the notation described here.
6657 </para>
6658 </listitem>
6659
6660 <listitem>
6661 <para>
6662 &ldquo;<ulink url="http://www.soi.city.ac.uk/~ross/papers/fop.html">Arrows and Computation</ulink>&rdquo;,
6663 Ross Paterson, in <citetitle>The Fun of Programming</citetitle>,
6664 Palgrave, 2003.
6665 </para>
6666 </listitem>
6667
6668 <listitem>
6669 <para>
6670 &ldquo;<ulink url="http://www.cs.chalmers.se/~rjmh/afp-arrows.pdf">Programming with Arrows</ulink>&rdquo;,
6671 John Hughes, in <citetitle>5th International Summer School on
6672 Advanced Functional Programming</citetitle>,
6673 <citetitle>Lecture Notes in Computer Science</citetitle> vol. 3622,
6674 Springer, 2004.
6675 This paper includes another introduction to the notation,
6676 with practical examples.
6677 </para>
6678 </listitem>
6679
6680 <listitem>
6681 <para>
6682 &ldquo;<ulink url="http://www.haskell.org/ghc/docs/papers/arrow-rules.pdf">Type and Translation Rules for Arrow Notation in GHC</ulink>&rdquo;,
6683 Ross Paterson and Simon Peyton Jones, September 16, 2004.
6684 A terse enumeration of the formal rules used
6685 (extracted from comments in the source code).
6686 </para>
6687 </listitem>
6688
6689 <listitem>
6690 <para>
6691 The arrows web page at
6692 <ulink url="http://www.haskell.org/arrows/"><literal>http://www.haskell.org/arrows/</literal></ulink>.
6693 </para>
6694 </listitem>
6695
6696 </itemizedlist>
6697 With the <option>-XArrows</option> flag, GHC supports the arrow
6698 notation described in the second of these papers,
6699 translating it using combinators from the
6700 <ulink url="&libraryBaseLocation;/Control-Arrow.html"><literal>Control.Arrow</literal></ulink>
6701 module.
6702 What follows is a brief introduction to the notation;
6703 it won't make much sense unless you've read Hughes's paper.
6704 </para>
6705
6706 <para>The extension adds a new kind of expression for defining arrows:
6707 <screen>
6708 <replaceable>exp</replaceable><superscript>10</superscript> ::= ...
6709        |  proc <replaceable>apat</replaceable> -> <replaceable>cmd</replaceable>
6710 </screen>
6711 where <literal>proc</literal> is a new keyword.
6712 The variables of the pattern are bound in the body of the
6713 <literal>proc</literal>-expression,
6714 which is a new sort of thing called a <firstterm>command</firstterm>.
6715 The syntax of commands is as follows:
6716 <screen>
6717 <replaceable>cmd</replaceable>   ::= <replaceable>exp</replaceable><superscript>10</superscript> -&lt;  <replaceable>exp</replaceable>
6718        |  <replaceable>exp</replaceable><superscript>10</superscript> -&lt;&lt; <replaceable>exp</replaceable>
6719        |  <replaceable>cmd</replaceable><superscript>0</superscript>
6720 </screen>
6721 with <replaceable>cmd</replaceable><superscript>0</superscript> up to
6722 <replaceable>cmd</replaceable><superscript>9</superscript> defined using
6723 infix operators as for expressions, and
6724 <screen>
6725 <replaceable>cmd</replaceable><superscript>10</superscript> ::= \ <replaceable>apat</replaceable> ... <replaceable>apat</replaceable> -> <replaceable>cmd</replaceable>
6726        |  let <replaceable>decls</replaceable> in <replaceable>cmd</replaceable>
6727        |  if <replaceable>exp</replaceable> then <replaceable>cmd</replaceable> else <replaceable>cmd</replaceable>
6728        |  case <replaceable>exp</replaceable> of { <replaceable>calts</replaceable> }
6729        |  do { <replaceable>cstmt</replaceable> ; ... <replaceable>cstmt</replaceable> ; <replaceable>cmd</replaceable> }
6730        |  <replaceable>fcmd</replaceable>
6731
6732 <replaceable>fcmd</replaceable>  ::= <replaceable>fcmd</replaceable> <replaceable>aexp</replaceable>
6733        |  ( <replaceable>cmd</replaceable> )
6734        |  (| <replaceable>aexp</replaceable> <replaceable>cmd</replaceable> ... <replaceable>cmd</replaceable> |)
6735
6736 <replaceable>cstmt</replaceable> ::= let <replaceable>decls</replaceable>
6737        |  <replaceable>pat</replaceable> &lt;- <replaceable>cmd</replaceable>
6738        |  rec { <replaceable>cstmt</replaceable> ; ... <replaceable>cstmt</replaceable> [;] }
6739        |  <replaceable>cmd</replaceable>
6740 </screen>
6741 where <replaceable>calts</replaceable> are like <replaceable>alts</replaceable>
6742 except that the bodies are commands instead of expressions.
6743 </para>
6744
6745 <para>
6746 Commands produce values, but (like monadic computations)
6747 may yield more than one value,
6748 or none, and may do other things as well.
6749 For the most part, familiarity with monadic notation is a good guide to
6750 using commands.
6751 However the values of expressions, even monadic ones,
6752 are determined by the values of the variables they contain;
6753 this is not necessarily the case for commands.
6754 </para>
6755
6756 <para>
6757 A simple example of the new notation is the expression
6758 <screen>
6759 proc x -> f -&lt; x+1
6760 </screen>
6761 We call this a <firstterm>procedure</firstterm> or
6762 <firstterm>arrow abstraction</firstterm>.
6763 As with a lambda expression, the variable <literal>x</literal>
6764 is a new variable bound within the <literal>proc</literal>-expression.
6765 It refers to the input to the arrow.
6766 In the above example, <literal>-&lt;</literal> is not an identifier but an
6767 new reserved symbol used for building commands from an expression of arrow
6768 type and an expression to be fed as input to that arrow.
6769 (The weird look will make more sense later.)
6770 It may be read as analogue of application for arrows.
6771 The above example is equivalent to the Haskell expression
6772 <screen>
6773 arr (\ x -> x+1) >>> f
6774 </screen>
6775 That would make no sense if the expression to the left of
6776 <literal>-&lt;</literal> involves the bound variable <literal>x</literal>.
6777 More generally, the expression to the left of <literal>-&lt;</literal>
6778 may not involve any <firstterm>local variable</firstterm>,
6779 i.e. a variable bound in the current arrow abstraction.
6780 For such a situation there is a variant <literal>-&lt;&lt;</literal>, as in
6781 <screen>
6782 proc x -> f x -&lt;&lt; x+1
6783 </screen>
6784 which is equivalent to
6785 <screen>
6786 arr (\ x -> (f x, x+1)) >>> app
6787 </screen>
6788 so in this case the arrow must belong to the <literal>ArrowApply</literal>
6789 class.
6790 Such an arrow is equivalent to a monad, so if you're using this form
6791 you may find a monadic formulation more convenient.
6792 </para>
6793
6794 <sect2>
6795 <title>do-notation for commands</title>
6796
6797 <para>
6798 Another form of command is a form of <literal>do</literal>-notation.
6799 For example, you can write
6800 <screen>
6801 proc x -> do
6802         y &lt;- f -&lt; x+1
6803         g -&lt; 2*y
6804         let z = x+y
6805         t &lt;- h -&lt; x*z
6806         returnA -&lt; t+z
6807 </screen>
6808 You can read this much like ordinary <literal>do</literal>-notation,
6809 but with commands in place of monadic expressions.
6810 The first line sends the value of <literal>x+1</literal> as an input to
6811 the arrow <literal>f</literal>, and matches its output against
6812 <literal>y</literal>.
6813 In the next line, the output is discarded.
6814 The arrow <function>returnA</function> is defined in the
6815 <ulink url="&libraryBaseLocation;/Control-Arrow.html"><literal>Control.Arrow</literal></ulink>
6816 module as <literal>arr id</literal>.
6817 The above example is treated as an abbreviation for
6818 <screen>
6819 arr (\ x -> (x, x)) >>>
6820         first (arr (\ x -> x+1) >>> f) >>>
6821         arr (\ (y, x) -> (y, (x, y))) >>>
6822         first (arr (\ y -> 2*y) >>> g) >>>
6823         arr snd >>>
6824         arr (\ (x, y) -> let z = x+y in ((x, z), z)) >>>
6825         first (arr (\ (x, z) -> x*z) >>> h) >>>
6826         arr (\ (t, z) -> t+z) >>>
6827         returnA
6828 </screen>
6829 Note that variables not used later in the composition are projected out.
6830 After simplification using rewrite rules (see <xref linkend="rewrite-rules"/>)
6831 defined in the
6832 <ulink url="&libraryBaseLocation;/Control-Arrow.html"><literal>Control.Arrow</literal></ulink>
6833 module, this reduces to
6834 <screen>
6835 arr (\ x -> (x+1, x)) >>>
6836         first f >>>
6837         arr (\ (y, x) -> (2*y, (x, y))) >>>
6838         first g >>>
6839         arr (\ (_, (x, y)) -> let z = x+y in (x*z, z)) >>>
6840         first h >>>
6841         arr (\ (t, z) -> t+z)
6842 </screen>
6843 which is what you might have written by hand.
6844 With arrow notation, GHC keeps track of all those tuples of variables for you.
6845 </para>
6846
6847 <para>
6848 Note that although the above translation suggests that
6849 <literal>let</literal>-bound variables like <literal>z</literal> must be
6850 monomorphic, the actual translation produces Core,
6851 so polymorphic variables are allowed.
6852 </para>
6853
6854 <para>
6855 It's also possible to have mutually recursive bindings,
6856 using the new <literal>rec</literal> keyword, as in the following example:
6857 <programlisting>
6858 counter :: ArrowCircuit a => a Bool Int
6859 counter = proc reset -> do
6860         rec     output &lt;- returnA -&lt; if reset then 0 else next
6861                 next &lt;- delay 0 -&lt; output+1
6862         returnA -&lt; output
6863 </programlisting>
6864 The translation of such forms uses the <function>loop</function> combinator,
6865 so the arrow concerned must belong to the <literal>ArrowLoop</literal> class.
6866 </para>
6867
6868 </sect2>
6869
6870 <sect2>
6871 <title>Conditional commands</title>
6872
6873 <para>
6874 In the previous example, we used a conditional expression to construct the
6875 input for an arrow.
6876 Sometimes we want to conditionally execute different commands, as in
6877 <screen>
6878 proc (x,y) ->
6879         if f x y
6880         then g -&lt; x+1
6881         else h -&lt; y+2
6882 </screen>
6883 which is translated to
6884 <screen>
6885 arr (\ (x,y) -> if f x y then Left x else Right y) >>>
6886         (arr (\x -> x+1) >>> f) ||| (arr (\y -> y+2) >>> g)
6887 </screen>
6888 Since the translation uses <function>|||</function>,
6889 the arrow concerned must belong to the <literal>ArrowChoice</literal> class.
6890 </para>
6891
6892 <para>
6893 There are also <literal>case</literal> commands, like
6894 <screen>
6895 case input of
6896     [] -> f -&lt; ()
6897     [x] -> g -&lt; x+1
6898     x1:x2:xs -> do
6899         y &lt;- h -&lt; (x1, x2)
6900         ys &lt;- k -&lt; xs
6901         returnA -&lt; y:ys
6902 </screen>
6903 The syntax is the same as for <literal>case</literal> expressions,
6904 except that the bodies of the alternatives are commands rather than expressions.
6905 The translation is similar to that of <literal>if</literal> commands.
6906 </para>
6907
6908 </sect2>
6909
6910 <sect2>
6911 <title>Defining your own control structures</title>
6912
6913 <para>
6914 As we're seen, arrow notation provides constructs,
6915 modelled on those for expressions,
6916 for sequencing, value recursion and conditionals.
6917 But suitable combinators,
6918 which you can define in ordinary Haskell,
6919 may also be used to build new commands out of existing ones.
6920 The basic idea is that a command defines an arrow from environments to values.
6921 These environments assign values to the free local variables of the command.
6922 Thus combinators that produce arrows from arrows
6923 may also be used to build commands from commands.
6924 For example, the <literal>ArrowChoice</literal> class includes a combinator
6925 <programlisting>
6926 ArrowChoice a => (&lt;+>) :: a e c -> a e c -> a e c
6927 </programlisting>
6928 so we can use it to build commands:
6929 <programlisting>
6930 expr' = proc x -> do
6931                 returnA -&lt; x
6932         &lt;+> do
6933                 symbol Plus -&lt; ()
6934                 y &lt;- term -&lt; ()
6935                 expr' -&lt; x + y
6936         &lt;+> do
6937                 symbol Minus -&lt; ()
6938                 y &lt;- term -&lt; ()
6939                 expr' -&lt; x - y
6940 </programlisting>
6941 (The <literal>do</literal> on the first line is needed to prevent the first
6942 <literal>&lt;+> ...</literal> from being interpreted as part of the
6943 expression on the previous line.)
6944 This is equivalent to
6945 <programlisting>
6946 expr' = (proc x -> returnA -&lt; x)
6947         &lt;+> (proc x -> do
6948                 symbol Plus -&lt; ()
6949                 y &lt;- term -&lt; ()
6950                 expr' -&lt; x + y)
6951         &lt;+> (proc x -> do
6952                 symbol Minus -&lt; ()
6953                 y &lt;- term -&lt; ()
6954                 expr' -&lt; x - y)
6955 </programlisting>
6956 It is essential that this operator be polymorphic in <literal>e</literal>
6957 (representing the environment input to the command
6958 and thence to its subcommands)
6959 and satisfy the corresponding naturality property
6960 <screen>
6961 arr k >>> (f &lt;+> g) = (arr k >>> f) &lt;+> (arr k >>> g)
6962 </screen>
6963 at least for strict <literal>k</literal>.
6964 (This should be automatic if you're not using <function>seq</function>.)
6965 This ensures that environments seen by the subcommands are environments
6966 of the whole command,
6967 and also allows the translation to safely trim these environments.
6968 The operator must also not use any variable defined within the current
6969 arrow abstraction.
6970 </para>
6971
6972 <para>
6973 We could define our own operator
6974 <programlisting>
6975 untilA :: ArrowChoice a => a e () -> a e Bool -> a e ()
6976 untilA body cond = proc x ->
6977         b &lt;- cond -&lt; x
6978         if b then returnA -&lt; ()
6979         else do
6980                 body -&lt; x
6981                 untilA body cond -&lt; x
6982 </programlisting>
6983 and use it in the same way.
6984 Of course this infix syntax only makes sense for binary operators;
6985 there is also a more general syntax involving special brackets:
6986 <screen>
6987 proc x -> do
6988         y &lt;- f -&lt; x+1
6989         (|untilA (increment -&lt; x+y) (within 0.5 -&lt; x)|)
6990 </screen>
6991 </para>
6992
6993 </sect2>
6994
6995 <sect2>
6996 <title>Primitive constructs</title>
6997
6998 <para>
6999 Some operators will need to pass additional inputs to their subcommands.
7000 For example, in an arrow type supporting exceptions,
7001 the operator that attaches an exception handler will wish to pass the
7002 exception that occurred to the handler.
7003 Such an operator might have a type
7004 <screen>
7005 handleA :: ... => a e c -> a (e,Ex) c -> a e c
7006 </screen>
7007 where <literal>Ex</literal> is the type of exceptions handled.
7008 You could then use this with arrow notation by writing a command
7009 <screen>
7010 body `handleA` \ ex -> handler
7011 </screen>
7012 so that if an exception is raised in the command <literal>body</literal>,
7013 the variable <literal>ex</literal> is bound to the value of the exception
7014 and the command <literal>handler</literal>,
7015 which typically refers to <literal>ex</literal>, is entered.
7016 Though the syntax here looks like a functional lambda,
7017 we are talking about commands, and something different is going on.
7018 The input to the arrow represented by a command consists of values for
7019 the free local variables in the command, plus a stack of anonymous values.
7020 In all the prior examples, this stack was empty.
7021 In the second argument to <function>handleA</function>,
7022 this stack consists of one value, the value of the exception.
7023 The command form of lambda merely gives this value a name.
7024 </para>
7025
7026 <para>
7027 More concretely,
7028 the values on the stack are paired to the right of the environment.
7029 So operators like <function>handleA</function> that pass
7030 extra inputs to their subcommands can be designed for use with the notation
7031 by pairing the values with the environment in this way.
7032 More precisely, the type of each argument of the operator (and its result)
7033 should have the form
7034 <screen>
7035 a (...(e,t1), ... tn) t
7036 </screen>
7037 where <replaceable>e</replaceable> is a polymorphic variable
7038 (representing the environment)
7039 and <replaceable>ti</replaceable> are the types of the values on the stack,
7040 with <replaceable>t1</replaceable> being the <quote>top</quote>.
7041 The polymorphic variable <replaceable>e</replaceable> must not occur in
7042 <replaceable>a</replaceable>, <replaceable>ti</replaceable> or
7043 <replaceable>t</replaceable>.
7044 However the arrows involved need not be the same.
7045 Here are some more examples of suitable operators:
7046 <screen>
7047 bracketA :: ... => a e b -> a (e,b) c -> a (e,c) d -> a e d
7048 runReader :: ... => a e c -> a' (e,State) c
7049 runState :: ... => a e c -> a' (e,State) (c,State)
7050 </screen>
7051 We can supply the extra input required by commands built with the last two
7052 by applying them to ordinary expressions, as in
7053 <screen>
7054 proc x -> do
7055         s &lt;- ...
7056         (|runReader (do { ... })|) s
7057 </screen>
7058 which adds <literal>s</literal> to the stack of inputs to the command
7059 built using <function>runReader</function>.
7060 </para>
7061
7062 <para>
7063 The command versions of lambda abstraction and application are analogous to
7064 the expression versions.
7065 In particular, the beta and eta rules describe equivalences of commands.
7066 These three features (operators, lambda abstraction and application)
7067 are the core of the notation; everything else can be built using them,
7068 though the results would be somewhat clumsy.
7069 For example, we could simulate <literal>do</literal>-notation by defining
7070 <programlisting>
7071 bind :: Arrow a => a e b -> a (e,b) c -> a e c
7072 u `bind` f = returnA &amp;&amp;&amp; u >>> f
7073
7074 bind_ :: Arrow a => a e b -> a e c -> a e c
7075 u `bind_` f = u `bind` (arr fst >>> f)
7076 </programlisting>
7077 We could simulate <literal>if</literal> by defining
7078 <programlisting>
7079 cond :: ArrowChoice a => a e b -> a e b -> a (e,Bool) b
7080 cond f g = arr (\ (e,b) -> if b then Left e else Right e) >>> f ||| g
7081 </programlisting>
7082 </para>
7083
7084 </sect2>
7085
7086 <sect2>
7087 <title>Differences with the paper</title>
7088
7089 <itemizedlist>
7090
7091 <listitem>
7092 <para>Instead of a single form of arrow application (arrow tail) with two
7093 translations, the implementation provides two forms
7094 <quote><literal>-&lt;</literal></quote> (first-order)
7095 and <quote><literal>-&lt;&lt;</literal></quote> (higher-order).
7096 </para>
7097 </listitem>
7098
7099 <listitem>
7100 <para>User-defined operators are flagged with banana brackets instead of
7101 a new <literal>form</literal> keyword.
7102 </para>
7103 </listitem>
7104
7105 </itemizedlist>
7106
7107 </sect2>
7108
7109 <sect2>
7110 <title>Portability</title>
7111
7112 <para>
7113 Although only GHC implements arrow notation directly,
7114 there is also a preprocessor
7115 (available from the
7116 <ulink url="http://www.haskell.org/arrows/">arrows web page</ulink>)
7117 that translates arrow notation into Haskell 98
7118 for use with other Haskell systems.
7119 You would still want to check arrow programs with GHC;
7120 tracing type errors in the preprocessor output is not easy.
7121 Modules intended for both GHC and the preprocessor must observe some
7122 additional restrictions:
7123 <itemizedlist>
7124
7125 <listitem>
7126 <para>
7127 The module must import
7128 <ulink url="&libraryBaseLocation;/Control-Arrow.html"><literal>Control.Arrow</literal></ulink>.
7129 </para>
7130 </listitem>
7131
7132 <listitem>
7133 <para>
7134 The preprocessor cannot cope with other Haskell extensions.
7135 These would have to go in separate modules.
7136 </para>
7137 </listitem>
7138
7139 <listitem>
7140 <para>
7141 Because the preprocessor targets Haskell (rather than Core),
7142 <literal>let</literal>-bound variables are monomorphic.
7143 </para>
7144 </listitem>
7145
7146 </itemizedlist>
7147 </para>
7148
7149 </sect2>
7150
7151 </sect1>
7152
7153 <!-- ==================== BANG PATTERNS =================  -->
7154
7155 <sect1 id="bang-patterns">
7156 <title>Bang patterns
7157 <indexterm><primary>Bang patterns</primary></indexterm>
7158 </title>
7159 <para>GHC supports an extension of pattern matching called <emphasis>bang
7160 patterns</emphasis>, written <literal>!<replaceable>pat</replaceable></literal>.
7161 Bang patterns are under consideration for Haskell Prime.
7162 The <ulink
7163 url="http://hackage.haskell.org/trac/haskell-prime/wiki/BangPatterns">Haskell
7164 prime feature description</ulink> contains more discussion and examples
7165 than the material below.
7166 </para>
7167 <para>
7168 The key change is the addition of a new rule to the
7169 <ulink url="http://haskell.org/onlinereport/exps.html#sect3.17.2">semantics of pattern matching in the Haskell 98 report</ulink>.
7170 Add new bullet 10, saying: Matching the pattern <literal>!</literal><replaceable>pat</replaceable>
7171 against a value <replaceable>v</replaceable> behaves as follows:
7172 <itemizedlist>
7173 <listitem><para>if <replaceable>v</replaceable> is bottom, the match diverges</para></listitem>
7174 <listitem><para>otherwise, <replaceable>pat</replaceable> is matched against <replaceable>v</replaceable>  </para></listitem>
7175 </itemizedlist>
7176 </para>
7177 <para>
7178 Bang patterns are enabled by the flag <option>-XBangPatterns</option>.
7179 </para>
7180
7181 <sect2 id="bang-patterns-informal">
7182 <title>Informal description of bang patterns
7183 </title>
7184 <para>
7185 The main idea is to add a single new production to the syntax of patterns:
7186 <programlisting>
7187   pat ::= !pat
7188 </programlisting>
7189 Matching an expression <literal>e</literal> against a pattern <literal>!p</literal> is done by first
7190 evaluating <literal>e</literal> (to WHNF) and then matching the result against <literal>p</literal>.
7191 Example:
7192 <programlisting>
7193 f1 !x = True
7194 </programlisting>
7195 This definition makes <literal>f1</literal> is strict in <literal>x</literal>,
7196 whereas without the bang it would be lazy.
7197 Bang patterns can be nested of course:
7198 <programlisting>
7199 f2 (!x, y) = [x,y]
7200 </programlisting>
7201 Here, <literal>f2</literal> is strict in <literal>x</literal> but not in
7202 <literal>y</literal>.
7203 A bang only really has an effect if it precedes a variable or wild-card pattern:
7204 <programlisting>
7205 f3 !(x,y) = [x,y]
7206 f4 (x,y)  = [x,y]
7207 </programlisting>
7208 Here, <literal>f3</literal> and <literal>f4</literal> are identical;
7209 putting a bang before a pattern that
7210 forces evaluation anyway does nothing.
7211 </para>
7212 <para>
7213 There is one (apparent) exception to this general rule that a bang only
7214 makes a difference when it precedes a variable or wild-card: a bang at the
7215 top level of a <literal>let</literal> or <literal>where</literal>
7216 binding makes the binding strict, regardless of the pattern. For example:
7217 <programlisting>
7218 let ![x,y] = e in b
7219 </programlisting>
7220 is a strict binding: operationally, it evaluates <literal>e</literal>, matches
7221 it against the pattern <literal>[x,y]</literal>, and then evaluates <literal>b</literal>.
7222 (We say "apparent" exception because the Right Way to think of it is that the bang
7223 at the top of a binding is not part of the <emphasis>pattern</emphasis>; rather it
7224 is part of the syntax of the <emphasis>binding</emphasis>.)
7225 Nested bangs in a pattern binding behave uniformly with all other forms of
7226 pattern matching.  For example
7227 <programlisting>
7228 let (!x,[y]) = e in b
7229 </programlisting>
7230 is equivalent to this:
7231 <programlisting>
7232 let { t = case e of (x,[y]) -> x `seq` (x,y)
7233       x = fst t
7234       y = snd t }
7235 in b
7236 </programlisting>
7237 The binding is lazy, but when either <literal>x</literal> or <literal>y</literal> is
7238 evaluated by <literal>b</literal> the entire pattern is matched, including forcing the
7239 evaluation of <literal>x</literal>.
7240 </para>
7241 <para>
7242 Bang patterns work in <literal>case</literal> expressions too, of course:
7243 <programlisting>
7244 g5 x = let y = f x in body
7245 g6 x = case f x of { y -&gt; body }
7246 g7 x = case f x of { !y -&gt; body }
7247 </programlisting>
7248 The functions <literal>g5</literal> and <literal>g6</literal> mean exactly the same thing.
7249 But <literal>g7</literal> evaluates <literal>(f x)</literal>, binds <literal>y</literal> to the
7250 result, and then evaluates <literal>body</literal>.
7251 </para>
7252 </sect2>
7253
7254
7255 <sect2 id="bang-patterns-sem">
7256 <title>Syntax and semantics
7257 </title>
7258 <para>
7259
7260 We add a single new production to the syntax of patterns:
7261 <programlisting>
7262   pat ::= !pat
7263 </programlisting>
7264 There is one problem with syntactic ambiguity.  Consider:
7265 <programlisting>
7266 f !x = 3
7267 </programlisting>
7268 Is this a definition of the infix function "<literal>(!)</literal>",
7269 or of the "<literal>f</literal>" with a bang pattern? GHC resolves this
7270 ambiguity in favour of the latter.  If you want to define
7271 <literal>(!)</literal> with bang-patterns enabled, you have to do so using
7272 prefix notation:
7273 <programlisting>
7274 (!) f x = 3
7275 </programlisting>
7276 The semantics of Haskell pattern matching is described in <ulink
7277 url="http://www.haskell.org/onlinereport/exps.html#sect3.17.2">
7278 Section 3.17.2</ulink> of the Haskell Report.  To this description add
7279 one extra item 10, saying:
7280 <itemizedlist><listitem><para>Matching
7281 the pattern <literal>!pat</literal> against a value <literal>v</literal> behaves as follows:
7282 <itemizedlist><listitem><para>if <literal>v</literal> is bottom, the match diverges</para></listitem>
7283                 <listitem><para>otherwise, <literal>pat</literal> is matched against
7284                 <literal>v</literal></para></listitem>
7285 </itemizedlist>
7286 </para></listitem></itemizedlist>
7287 Similarly, in Figure 4 of  <ulink url="http://www.haskell.org/onlinereport/exps.html#sect3.17.3">
7288 Section 3.17.3</ulink>, add a new case (t):
7289 <programlisting>
7290 case v of { !pat -> e; _ -> e' }
7291    = v `seq` case v of { pat -> e; _ -> e' }
7292 </programlisting>
7293 </para><para>
7294 That leaves let expressions, whose translation is given in
7295 <ulink url="http://www.haskell.org/onlinereport/exps.html#sect3.12">Section
7296 3.12</ulink>
7297 of the Haskell Report.
7298 In the translation box, first apply
7299 the following transformation:  for each pattern <literal>pi</literal> that is of
7300 form <literal>!qi = ei</literal>, transform it to <literal>(xi,!qi) = ((),ei)</literal>, and and replace <literal>e0</literal>
7301 by <literal>(xi `seq` e0)</literal>.  Then, when none of the left-hand-side patterns
7302 have a bang at the top, apply the rules in the existing box.
7303 </para>
7304 <para>The effect of the let rule is to force complete matching of the pattern
7305 <literal>qi</literal> before evaluation of the body is begun.  The bang is
7306 retained in the translated form in case <literal>qi</literal> is a variable,
7307 thus:
7308 <programlisting>
7309   let !y = f x in b
7310 </programlisting>
7311
7312 </para>
7313 <para>
7314 The let-binding can be recursive.  However, it is much more common for
7315 the let-binding to be non-recursive, in which case the following law holds:
7316 <literal>(let !p = rhs in body)</literal>
7317      is equivalent to
7318 <literal>(case rhs of !p -> body)</literal>
7319 </para>
7320 <para>
7321 A pattern with a bang at the outermost level is not allowed at the top level of
7322 a module.
7323 </para>
7324 </sect2>
7325 </sect1>
7326
7327 <!-- ==================== ASSERTIONS =================  -->
7328
7329 <sect1 id="assertions">
7330 <title>Assertions
7331 <indexterm><primary>Assertions</primary></indexterm>
7332 </title>
7333
7334 <para>
7335 If you want to make use of assertions in your standard Haskell code, you
7336 could define a function like the following:
7337 </para>
7338
7339 <para>
7340
7341 <programlisting>
7342 assert :: Bool -> a -> a
7343 assert False x = error "assertion failed!"
7344 assert _     x = x
7345 </programlisting>
7346
7347 </para>
7348
7349 <para>
7350 which works, but gives you back a less than useful error message --
7351 an assertion failed, but which and where?
7352 </para>
7353
7354 <para>
7355 One way out is to define an extended <function>assert</function> function which also
7356 takes a descriptive string to include in the error message and
7357 perhaps combine this with the use of a pre-processor which inserts
7358 the source location where <function>assert</function> was used.
7359 </para>
7360
7361 <para>
7362 Ghc offers a helping hand here, doing all of this for you. For every
7363 use of <function>assert</function> in the user's source:
7364 </para>
7365
7366 <para>
7367
7368 <programlisting>
7369 kelvinToC :: Double -> Double
7370 kelvinToC k = assert (k &gt;= 0.0) (k+273.15)
7371 </programlisting>
7372
7373 </para>
7374
7375 <para>
7376 Ghc will rewrite this to also include the source location where the
7377 assertion was made,
7378 </para>
7379
7380 <para>
7381
7382 <programlisting>
7383 assert pred val ==> assertError "Main.hs|15" pred val
7384 </programlisting>
7385
7386 </para>
7387
7388 <para>
7389 The rewrite is only performed by the compiler when it spots
7390 applications of <function>Control.Exception.assert</function>, so you
7391 can still define and use your own versions of
7392 <function>assert</function>, should you so wish. If not, import
7393 <literal>Control.Exception</literal> to make use
7394 <function>assert</function> in your code.
7395 </para>
7396
7397 <para>
7398 GHC ignores assertions when optimisation is turned on with the
7399       <option>-O</option><indexterm><primary><option>-O</option></primary></indexterm> flag.  That is, expressions of the form
7400 <literal>assert pred e</literal> will be rewritten to
7401 <literal>e</literal>.  You can also disable assertions using the
7402       <option>-fignore-asserts</option>
7403       option<indexterm><primary><option>-fignore-asserts</option></primary>
7404       </indexterm>.</para>
7405
7406 <para>
7407 Assertion failures can be caught, see the documentation for the
7408 <literal>Control.Exception</literal> library for the details.
7409 </para>
7410
7411 </sect1>
7412
7413
7414 <!-- =============================== PRAGMAS ===========================  -->
7415
7416   <sect1 id="pragmas">
7417     <title>Pragmas</title>
7418
7419     <indexterm><primary>pragma</primary></indexterm>
7420
7421     <para>GHC supports several pragmas, or instructions to the
7422     compiler placed in the source code.  Pragmas don't normally affect
7423     the meaning of the program, but they might affect the efficiency
7424     of the generated code.</para>
7425
7426     <para>Pragmas all take the form
7427
7428 <literal>{-# <replaceable>word</replaceable> ... #-}</literal>
7429
7430     where <replaceable>word</replaceable> indicates the type of
7431     pragma, and is followed optionally by information specific to that
7432     type of pragma.  Case is ignored in
7433     <replaceable>word</replaceable>.  The various values for
7434     <replaceable>word</replaceable> that GHC understands are described
7435     in the following sections; any pragma encountered with an
7436     unrecognised <replaceable>word</replaceable> is
7437     ignored. The layout rule applies in pragmas, so the closing <literal>#-}</literal>
7438     should start in a column to the right of the opening <literal>{-#</literal>. </para>
7439
7440     <para>Certain pragmas are <emphasis>file-header pragmas</emphasis>:
7441       <itemizedlist>
7442       <listitem><para>
7443           A file-header
7444           pragma must precede the <literal>module</literal> keyword in the file.
7445           </para></listitem>
7446       <listitem><para>
7447       There can be as many file-header pragmas as you please, and they can be
7448       preceded or followed by comments.
7449           </para></listitem>
7450       <listitem><para>
7451       File-header pragmas are read once only, before
7452       pre-processing the file (e.g. with cpp).
7453           </para></listitem>
7454       <listitem><para>
7455          The file-header pragmas are: <literal>{-# LANGUAGE #-}</literal>,
7456         <literal>{-# OPTIONS_GHC #-}</literal>, and
7457         <literal>{-# INCLUDE #-}</literal>.
7458           </para></listitem>
7459       </itemizedlist>
7460       </para>
7461
7462     <sect2 id="language-pragma">
7463       <title>LANGUAGE pragma</title>
7464
7465       <indexterm><primary>LANGUAGE</primary><secondary>pragma</secondary></indexterm>
7466       <indexterm><primary>pragma</primary><secondary>LANGUAGE</secondary></indexterm>
7467
7468       <para>The <literal>LANGUAGE</literal> pragma allows language extensions to be enabled
7469         in a portable way.
7470         It is the intention that all Haskell compilers support the
7471         <literal>LANGUAGE</literal> pragma with the same syntax, although not
7472         all extensions are supported by all compilers, of
7473         course.  The <literal>LANGUAGE</literal> pragma should be used instead
7474         of <literal>OPTIONS_GHC</literal>, if possible.</para>
7475
7476       <para>For example, to enable the FFI and preprocessing with CPP:</para>
7477
7478 <programlisting>{-# LANGUAGE ForeignFunctionInterface, CPP #-}</programlisting>
7479
7480         <para><literal>LANGUAGE</literal> is a file-header pragma (see <xref linkend="pragmas"/>).</para>
7481
7482       <para>Every language extension can also be turned into a command-line flag
7483         by prefixing it with "<literal>-X</literal>"; for example <option>-XForeignFunctionInterface</option>.
7484         (Similarly, all "<literal>-X</literal>" flags can be written as <literal>LANGUAGE</literal> pragmas.
7485       </para>
7486
7487       <para>A list of all supported language extensions can be obtained by invoking
7488         <literal>ghc --supported-languages</literal> (see <xref linkend="modes"/>).</para>
7489
7490       <para>Any extension from the <literal>Extension</literal> type defined in
7491         <ulink
7492           url="&libraryCabalLocation;/Language-Haskell-Extension.html"><literal>Language.Haskell.Extension</literal></ulink>
7493         may be used.  GHC will report an error if any of the requested extensions are not supported.</para>
7494     </sect2>
7495
7496
7497     <sect2 id="options-pragma">
7498       <title>OPTIONS_GHC pragma</title>
7499       <indexterm><primary>OPTIONS_GHC</primary>
7500       </indexterm>
7501       <indexterm><primary>pragma</primary><secondary>OPTIONS_GHC</secondary>
7502       </indexterm>
7503
7504       <para>The <literal>OPTIONS_GHC</literal> pragma is used to specify
7505       additional options that are given to the compiler when compiling
7506       this source file.  See <xref linkend="source-file-options"/> for
7507       details.</para>
7508
7509       <para>Previous versions of GHC accepted <literal>OPTIONS</literal> rather
7510         than <literal>OPTIONS_GHC</literal>, but that is now deprecated.</para>
7511     </sect2>
7512
7513         <para><literal>OPTIONS_GHC</literal> is a file-header pragma (see <xref linkend="pragmas"/>).</para>
7514
7515     <sect2 id="include-pragma">
7516       <title>INCLUDE pragma</title>
7517
7518       <para>The <literal>INCLUDE</literal> used to be necessary for
7519         specifying header files to be included when using the FFI and
7520         compiling via C.  It is no longer required for GHC, but is
7521         accepted (and ignored) for compatibility with other
7522         compilers.</para>
7523     </sect2>
7524
7525     <sect2 id="warning-deprecated-pragma">
7526       <title>WARNING and DEPRECATED pragmas</title>
7527       <indexterm><primary>WARNING</primary></indexterm>
7528       <indexterm><primary>DEPRECATED</primary></indexterm>
7529
7530       <para>The WARNING pragma allows you to attach an arbitrary warning
7531       to a particular function, class, or type.
7532       A DEPRECATED pragma lets you specify that
7533       a particular function, class, or type is deprecated.
7534       There are two ways of using these pragmas.
7535
7536       <itemizedlist>
7537         <listitem>
7538           <para>You can work on an entire module thus:</para>
7539 <programlisting>
7540    module Wibble {-# DEPRECATED "Use Wobble instead" #-} where
7541      ...
7542 </programlisting>
7543       <para>Or:</para>
7544 <programlisting>
7545    module Wibble {-# WARNING "This is an unstable interface." #-} where
7546      ...
7547 </programlisting>
7548           <para>When you compile any module that import
7549           <literal>Wibble</literal>, GHC will print the specified
7550           message.</para>
7551         </listitem>
7552
7553         <listitem>
7554           <para>You can attach a warning to a function, class, type, or data constructor, with the
7555           following top-level declarations:</para>
7556 <programlisting>
7557    {-# DEPRECATED f, C, T "Don't use these" #-}
7558    {-# WARNING unsafePerformIO "This is unsafe; I hope you know what you're doing" #-}
7559 </programlisting>
7560           <para>When you compile any module that imports and uses any
7561           of the specified entities, GHC will print the specified
7562           message.</para>
7563           <para> You can only attach to entities declared at top level in the module
7564           being compiled, and you can only use unqualified names in the list of
7565           entities. A capitalised name, such as <literal>T</literal>
7566           refers to <emphasis>either</emphasis> the type constructor <literal>T</literal>
7567           <emphasis>or</emphasis> the data constructor <literal>T</literal>, or both if
7568           both are in scope.  If both are in scope, there is currently no way to
7569       specify one without the other (c.f. fixities
7570       <xref linkend="infix-tycons"/>).</para>
7571         </listitem>
7572       </itemizedlist>
7573       Warnings and deprecations are not reported for
7574       (a) uses within the defining module, and
7575       (b) uses in an export list.
7576       The latter reduces spurious complaints within a library
7577       in which one module gathers together and re-exports
7578       the exports of several others.
7579       </para>
7580       <para>You can suppress the warnings with the flag
7581       <option>-fno-warn-warnings-deprecations</option>.</para>
7582     </sect2>
7583
7584     <sect2 id="inline-noinline-pragma">
7585       <title>INLINE and NOINLINE pragmas</title>
7586
7587       <para>These pragmas control the inlining of function
7588       definitions.</para>
7589
7590       <sect3 id="inline-pragma">
7591         <title>INLINE pragma</title>
7592         <indexterm><primary>INLINE</primary></indexterm>
7593
7594         <para>GHC (with <option>-O</option>, as always) tries to
7595         inline (or &ldquo;unfold&rdquo;) functions/values that are
7596         &ldquo;small enough,&rdquo; thus avoiding the call overhead
7597         and possibly exposing other more-wonderful optimisations.
7598         Normally, if GHC decides a function is &ldquo;too
7599         expensive&rdquo; to inline, it will not do so, nor will it
7600         export that unfolding for other modules to use.</para>
7601
7602         <para>The sledgehammer you can bring to bear is the
7603         <literal>INLINE</literal><indexterm><primary>INLINE
7604         pragma</primary></indexterm> pragma, used thusly:</para>
7605
7606 <programlisting>
7607 key_function :: Int -> String -> (Bool, Double)
7608 {-# INLINE key_function #-}
7609 </programlisting>
7610
7611         <para>The major effect of an <literal>INLINE</literal> pragma
7612         is to declare a function's &ldquo;cost&rdquo; to be very low.
7613         The normal unfolding machinery will then be very keen to
7614         inline it.  However, an <literal>INLINE</literal> pragma for a
7615         function "<literal>f</literal>" has a number of other effects:
7616 <itemizedlist>
7617 <listitem><para>
7618 No functions are inlined into <literal>f</literal>.  Otherwise
7619 GHC might inline a big function into <literal>f</literal>'s right hand side,
7620 making <literal>f</literal> big; and then inline <literal>f</literal> blindly.
7621 </para></listitem>
7622 <listitem><para>
7623 The float-in, float-out, and common-sub-expression transformations are not
7624 applied to the body of <literal>f</literal>.
7625 </para></listitem>
7626 <listitem><para>
7627 An INLINE function is not worker/wrappered by strictness analysis.
7628 It's going to be inlined wholesale instead.
7629 </para></listitem>
7630 </itemizedlist>
7631 All of these effects are aimed at ensuring that what gets inlined is
7632 exactly what you asked for, no more and no less.
7633 </para>
7634 <para>GHC ensures that inlining cannot go on forever: every mutually-recursive
7635 group is cut by one or more <emphasis>loop breakers</emphasis> that is never inlined
7636 (see <ulink url="http://research.microsoft.com/%7Esimonpj/Papers/inlining/index.htm">
7637 Secrets of the GHC inliner, JFP 12(4) July 2002</ulink>).
7638 GHC tries not to select a function with an INLINE pragma as a loop breaker, but
7639 when there is no choice even an INLINE function can be selected, in which case
7640 the INLINE pragma is ignored.
7641 For example, for a self-recursive function, the loop breaker can only be the function
7642 itself, so an INLINE pragma is always ignored.</para>
7643
7644         <para>Syntactically, an <literal>INLINE</literal> pragma for a
7645         function can be put anywhere its type signature could be
7646         put.</para>
7647
7648         <para><literal>INLINE</literal> pragmas are a particularly
7649         good idea for the
7650         <literal>then</literal>/<literal>return</literal> (or
7651         <literal>bind</literal>/<literal>unit</literal>) functions in
7652         a monad.  For example, in GHC's own
7653         <literal>UniqueSupply</literal> monad code, we have:</para>
7654
7655 <programlisting>
7656 {-# INLINE thenUs #-}
7657 {-# INLINE returnUs #-}
7658 </programlisting>
7659
7660         <para>See also the <literal>NOINLINE</literal> pragma (<xref
7661         linkend="noinline-pragma"/>).</para>
7662
7663         <para>Note: the HBC compiler doesn't like <literal>INLINE</literal> pragmas,
7664           so if you want your code to be HBC-compatible you'll have to surround
7665           the pragma with C pre-processor directives
7666           <literal>#ifdef __GLASGOW_HASKELL__</literal>...<literal>#endif</literal>.</para>
7667
7668       </sect3>
7669
7670       <sect3 id="noinline-pragma">
7671         <title>NOINLINE pragma</title>
7672
7673         <indexterm><primary>NOINLINE</primary></indexterm>
7674         <indexterm><primary>NOTINLINE</primary></indexterm>
7675
7676         <para>The <literal>NOINLINE</literal> pragma does exactly what
7677         you'd expect: it stops the named function from being inlined
7678         by the compiler.  You shouldn't ever need to do this, unless
7679         you're very cautious about code size.</para>
7680
7681         <para><literal>NOTINLINE</literal> is a synonym for
7682         <literal>NOINLINE</literal> (<literal>NOINLINE</literal> is
7683         specified by Haskell 98 as the standard way to disable
7684         inlining, so it should be used if you want your code to be
7685         portable).</para>
7686       </sect3>
7687
7688       <sect3 id="conlike-pragma">
7689         <title>CONLIKE modifier</title>
7690         <indexterm><primary>CONLIKE</primary></indexterm>
7691         <para>An INLINE or NOINLINE pragma may have a CONLIKE modifier,
7692         which affects matching in RULEs (only).  See <xref linkend="conlike"/>.
7693         </para>
7694       </sect3>
7695
7696       <sect3 id="phase-control">
7697         <title>Phase control</title>
7698
7699         <para> Sometimes you want to control exactly when in GHC's
7700         pipeline the INLINE pragma is switched on.  Inlining happens
7701         only during runs of the <emphasis>simplifier</emphasis>.  Each
7702         run of the simplifier has a different <emphasis>phase
7703         number</emphasis>; the phase number decreases towards zero.
7704         If you use <option>-dverbose-core2core</option> you'll see the
7705         sequence of phase numbers for successive runs of the
7706         simplifier.  In an INLINE pragma you can optionally specify a
7707         phase number, thus:
7708         <itemizedlist>
7709           <listitem>
7710             <para>"<literal>INLINE[k] f</literal>" means: do not inline
7711             <literal>f</literal>
7712               until phase <literal>k</literal>, but from phase
7713               <literal>k</literal> onwards be very keen to inline it.
7714             </para></listitem>
7715           <listitem>
7716             <para>"<literal>INLINE[~k] f</literal>" means: be very keen to inline
7717             <literal>f</literal>
7718               until phase <literal>k</literal>, but from phase
7719               <literal>k</literal> onwards do not inline it.
7720             </para></listitem>
7721           <listitem>
7722             <para>"<literal>NOINLINE[k] f</literal>" means: do not inline
7723             <literal>f</literal>
7724               until phase <literal>k</literal>, but from phase
7725               <literal>k</literal> onwards be willing to inline it (as if
7726               there was no pragma).
7727             </para></listitem>
7728             <listitem>
7729             <para>"<literal>NOINLINE[~k] f</literal>" means: be willing to inline
7730             <literal>f</literal>
7731               until phase <literal>k</literal>, but from phase
7732               <literal>k</literal> onwards do not inline it.
7733             </para></listitem>
7734         </itemizedlist>
7735 The same information is summarised here:
7736 <programlisting>
7737                            -- Before phase 2     Phase 2 and later
7738   {-# INLINE   [2]  f #-}  --      No                 Yes
7739   {-# INLINE   [~2] f #-}  --      Yes                No
7740   {-# NOINLINE [2]  f #-}  --      No                 Maybe
7741   {-# NOINLINE [~2] f #-}  --      Maybe              No
7742
7743   {-# INLINE   f #-}       --      Yes                Yes
7744   {-# NOINLINE f #-}       --      No                 No
7745 </programlisting>
7746 By "Maybe" we mean that the usual heuristic inlining rules apply (if the
7747 function body is small, or it is applied to interesting-looking arguments etc).
7748 Another way to understand the semantics is this:
7749 <itemizedlist>
7750 <listitem><para>For both INLINE and NOINLINE, the phase number says
7751 when inlining is allowed at all.</para></listitem>
7752 <listitem><para>The INLINE pragma has the additional effect of making the
7753 function body look small, so that when inlining is allowed it is very likely to
7754 happen.
7755 </para></listitem>
7756 </itemizedlist>
7757 </para>
7758 <para>The same phase-numbering control is available for RULES
7759         (<xref linkend="rewrite-rules"/>).</para>
7760       </sect3>
7761     </sect2>
7762
7763     <sect2 id="annotation-pragmas">
7764       <title>ANN pragmas</title>
7765
7766       <para>GHC offers the ability to annotate various code constructs with additional
7767       data by using three pragmas.  This data can then be inspected at a later date by
7768       using GHC-as-a-library.</para>
7769
7770       <sect3 id="ann-pragma">
7771         <title>Annotating values</title>
7772
7773         <indexterm><primary>ANN</primary></indexterm>
7774
7775         <para>Any expression that has both <literal>Typeable</literal> and <literal>Data</literal> instances may be attached to a top-level value
7776         binding using an <literal>ANN</literal> pragma. In particular, this means you can use <literal>ANN</literal>
7777         to annotate data constructors (e.g. <literal>Just</literal>) as well as normal values (e.g. <literal>take</literal>).
7778         By way of example, to annotate the function <literal>foo</literal> with the annotation <literal>Just "Hello"</literal>
7779         you would do this:</para>
7780
7781 <programlisting>
7782 {-# ANN foo (Just "Hello") #-}
7783 foo = ...
7784 </programlisting>
7785
7786         <para>
7787           A number of restrictions apply to use of annotations:
7788           <itemizedlist>
7789             <listitem><para>The binder being annotated must be at the top level (i.e. no nested binders)</para></listitem>
7790             <listitem><para>The binder being annotated must be declared in the current module</para></listitem>
7791             <listitem><para>The expression you are annotating with must have a type with <literal>Typeable</literal> and <literal>Data</literal> instances</para></listitem>
7792             <listitem><para>The <ulink linkend="using-template-haskell">Template Haskell staging restrictions</ulink> apply to the
7793             expression being annotated with, so for example you cannot run a function from the module being compiled.</para>
7794
7795             <para>To be precise, the annotation <literal>{-# ANN x e #-}</literal> is well staged if and only if <literal>$(e)</literal> would be
7796             (disregarding the usual type restrictions of the splice syntax, and the usual restriction on splicing inside a splice - <literal>$([|1|])</literal> is fine as an annotation, albeit redundant).</para></listitem>
7797           </itemizedlist>
7798
7799           If you feel strongly that any of these restrictions are too onerous, <ulink url="http://hackage.haskell.org/trac/ghc/wiki/MailingListsAndIRC">
7800           please give the GHC team a shout</ulink>.
7801         </para>
7802
7803         <para>However, apart from these restrictions, many things are allowed, including expressions which are not fully evaluated!
7804         Annotation expressions will be evaluated by the compiler just like Template Haskell splices are. So, this annotation is fine:</para>
7805
7806 <programlisting>
7807 {-# ANN f SillyAnnotation { foo = (id 10) + $([| 20 |]), bar = 'f } #-}
7808 f = ...
7809 </programlisting>
7810       </sect3>
7811
7812       <sect3 id="typeann-pragma">
7813         <title>Annotating types</title>
7814
7815         <indexterm><primary>ANN type</primary></indexterm>
7816         <indexterm><primary>ANN</primary></indexterm>
7817
7818         <para>You can annotate types with the <literal>ANN</literal> pragma by using the <literal>type</literal> keyword. For example:</para>
7819
7820 <programlisting>
7821 {-# ANN type Foo (Just "A `Maybe String' annotation") #-}
7822 data Foo = ...
7823 </programlisting>
7824       </sect3>
7825
7826       <sect3 id="modann-pragma">
7827         <title>Annotating modules</title>
7828
7829         <indexterm><primary>ANN module</primary></indexterm>
7830         <indexterm><primary>ANN</primary></indexterm>
7831
7832         <para>You can annotate modules with the <literal>ANN</literal> pragma by using the <literal>module</literal> keyword. For example:</para>
7833
7834 <programlisting>
7835 {-# ANN module (Just "A `Maybe String' annotation") #-}
7836 </programlisting>
7837       </sect3>
7838     </sect2>
7839
7840     <sect2 id="line-pragma">
7841       <title>LINE pragma</title>
7842
7843       <indexterm><primary>LINE</primary><secondary>pragma</secondary></indexterm>
7844       <indexterm><primary>pragma</primary><secondary>LINE</secondary></indexterm>
7845       <para>This pragma is similar to C's <literal>&num;line</literal>
7846       pragma, and is mainly for use in automatically generated Haskell
7847       code.  It lets you specify the line number and filename of the
7848       original code; for example</para>
7849
7850 <programlisting>{-# LINE 42 "Foo.vhs" #-}</programlisting>
7851
7852       <para>if you'd generated the current file from something called
7853       <filename>Foo.vhs</filename> and this line corresponds to line
7854       42 in the original.  GHC will adjust its error messages to refer
7855       to the line/file named in the <literal>LINE</literal>
7856       pragma.</para>
7857     </sect2>
7858
7859     <sect2 id="rules">
7860       <title>RULES pragma</title>
7861
7862       <para>The RULES pragma lets you specify rewrite rules.  It is
7863       described in <xref linkend="rewrite-rules"/>.</para>
7864     </sect2>
7865
7866     <sect2 id="specialize-pragma">
7867       <title>SPECIALIZE pragma</title>
7868
7869       <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
7870       <indexterm><primary>pragma, SPECIALIZE</primary></indexterm>
7871       <indexterm><primary>overloading, death to</primary></indexterm>
7872
7873       <para>(UK spelling also accepted.)  For key overloaded
7874       functions, you can create extra versions (NB: more code space)
7875       specialised to particular types.  Thus, if you have an
7876       overloaded function:</para>
7877
7878 <programlisting>
7879   hammeredLookup :: Ord key => [(key, value)] -> key -> value
7880 </programlisting>
7881
7882       <para>If it is heavily used on lists with
7883       <literal>Widget</literal> keys, you could specialise it as
7884       follows:</para>
7885
7886 <programlisting>
7887   {-# SPECIALIZE hammeredLookup :: [(Widget, value)] -> Widget -> value #-}
7888 </programlisting>
7889
7890       <para>A <literal>SPECIALIZE</literal> pragma for a function can
7891       be put anywhere its type signature could be put.</para>
7892
7893       <para>A <literal>SPECIALIZE</literal> has the effect of generating
7894       (a) a specialised version of the function and (b) a rewrite rule
7895       (see <xref linkend="rewrite-rules"/>) that rewrites a call to the
7896       un-specialised function into a call to the specialised one.</para>
7897
7898       <para>The type in a SPECIALIZE pragma can be any type that is less
7899         polymorphic than the type of the original function.  In concrete terms,
7900         if the original function is <literal>f</literal> then the pragma
7901 <programlisting>
7902   {-# SPECIALIZE f :: &lt;type&gt; #-}
7903 </programlisting>
7904       is valid if and only if the definition
7905 <programlisting>
7906   f_spec :: &lt;type&gt;
7907   f_spec = f
7908 </programlisting>
7909       is valid.  Here are some examples (where we only give the type signature
7910       for the original function, not its code):
7911 <programlisting>
7912   f :: Eq a => a -> b -> b
7913   {-# SPECIALISE f :: Int -> b -> b #-}
7914
7915   g :: (Eq a, Ix b) => a -> b -> b
7916   {-# SPECIALISE g :: (Eq a) => a -> Int -> Int #-}
7917
7918   h :: Eq a => a -> a -> a
7919   {-# SPECIALISE h :: (Eq a) => [a] -> [a] -> [a] #-}
7920 </programlisting>
7921 The last of these examples will generate a
7922 RULE with a somewhat-complex left-hand side (try it yourself), so it might not fire very
7923 well.  If you use this kind of specialisation, let us know how well it works.
7924 </para>
7925
7926 <para>A <literal>SPECIALIZE</literal> pragma can optionally be followed with a
7927 <literal>INLINE</literal> or <literal>NOINLINE</literal> pragma, optionally
7928 followed by a phase, as described in <xref linkend="inline-noinline-pragma"/>.
7929 The <literal>INLINE</literal> pragma affects the specialised version of the
7930 function (only), and applies even if the function is recursive.  The motivating
7931 example is this:
7932 <programlisting>
7933 -- A GADT for arrays with type-indexed representation
7934 data Arr e where
7935   ArrInt :: !Int -> ByteArray# -> Arr Int
7936   ArrPair :: !Int -> Arr e1 -> Arr e2 -> Arr (e1, e2)
7937
7938 (!:) :: Arr e -> Int -> e
7939 {-# SPECIALISE INLINE (!:) :: Arr Int -> Int -> Int #-}
7940 {-# SPECIALISE INLINE (!:) :: Arr (a, b) -> Int -> (a, b) #-}
7941 (ArrInt _ ba)     !: (I# i) = I# (indexIntArray# ba i)
7942 (ArrPair _ a1 a2) !: i      = (a1 !: i, a2 !: i)
7943 </programlisting>
7944 Here, <literal>(!:)</literal> is a recursive function that indexes arrays
7945 of type <literal>Arr e</literal>.  Consider a call to  <literal>(!:)</literal>
7946 at type <literal>(Int,Int)</literal>.  The second specialisation will fire, and
7947 the specialised function will be inlined.  It has two calls to
7948 <literal>(!:)</literal>,
7949 both at type <literal>Int</literal>.  Both these calls fire the first
7950 specialisation, whose body is also inlined.  The result is a type-based
7951 unrolling of the indexing function.</para>
7952 <para>Warning: you can make GHC diverge by using <literal>SPECIALISE INLINE</literal>
7953 on an ordinarily-recursive function.</para>
7954
7955       <para>Note: In earlier versions of GHC, it was possible to provide your own
7956       specialised function for a given type:
7957
7958 <programlisting>
7959 {-# SPECIALIZE hammeredLookup :: [(Int, value)] -> Int -> value = intLookup #-}
7960 </programlisting>
7961
7962       This feature has been removed, as it is now subsumed by the
7963       <literal>RULES</literal> pragma (see <xref linkend="rule-spec"/>).</para>
7964
7965     </sect2>
7966
7967 <sect2 id="specialize-instance-pragma">
7968 <title>SPECIALIZE instance pragma
7969 </title>
7970
7971 <para>
7972 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
7973 <indexterm><primary>overloading, death to</primary></indexterm>
7974 Same idea, except for instance declarations.  For example:
7975
7976 <programlisting>
7977 instance (Eq a) => Eq (Foo a) where {
7978    {-# SPECIALIZE instance Eq (Foo [(Int, Bar)]) #-}
7979    ... usual stuff ...
7980  }
7981 </programlisting>
7982 The pragma must occur inside the <literal>where</literal> part
7983 of the instance declaration.
7984 </para>
7985 <para>
7986 Compatible with HBC, by the way, except perhaps in the placement
7987 of the pragma.
7988 </para>
7989
7990 </sect2>
7991
7992     <sect2 id="unpack-pragma">
7993       <title>UNPACK pragma</title>
7994
7995       <indexterm><primary>UNPACK</primary></indexterm>
7996
7997       <para>The <literal>UNPACK</literal> indicates to the compiler
7998       that it should unpack the contents of a constructor field into
7999       the constructor itself, removing a level of indirection.  For
8000       example:</para>
8001
8002 <programlisting>
8003 data T = T {-# UNPACK #-} !Float
8004            {-# UNPACK #-} !Float
8005 </programlisting>
8006
8007       <para>will create a constructor <literal>T</literal> containing
8008       two unboxed floats.  This may not always be an optimisation: if
8009       the <function>T</function> constructor is scrutinised and the
8010       floats passed to a non-strict function for example, they will
8011       have to be reboxed (this is done automatically by the
8012       compiler).</para>
8013
8014       <para>Unpacking constructor fields should only be used in
8015       conjunction with <option>-O</option>, in order to expose
8016       unfoldings to the compiler so the reboxing can be removed as
8017       often as possible.  For example:</para>
8018
8019 <programlisting>
8020 f :: T -&#62; Float
8021 f (T f1 f2) = f1 + f2
8022 </programlisting>
8023
8024       <para>The compiler will avoid reboxing <function>f1</function>
8025       and <function>f2</function> by inlining <function>+</function>
8026       on floats, but only when <option>-O</option> is on.</para>
8027
8028       <para>Any single-constructor data is eligible for unpacking; for
8029       example</para>
8030
8031 <programlisting>
8032 data T = T {-# UNPACK #-} !(Int,Int)
8033 </programlisting>
8034
8035       <para>will store the two <literal>Int</literal>s directly in the
8036       <function>T</function> constructor, by flattening the pair.
8037       Multi-level unpacking is also supported:
8038
8039 <programlisting>
8040 data T = T {-# UNPACK #-} !S
8041 data S = S {-# UNPACK #-} !Int {-# UNPACK #-} !Int
8042 </programlisting>
8043
8044       will store two unboxed <literal>Int&num;</literal>s
8045       directly in the <function>T</function> constructor.  The
8046       unpacker can see through newtypes, too.</para>
8047
8048       <para>If a field cannot be unpacked, you will not get a warning,
8049       so it might be an idea to check the generated code with
8050       <option>-ddump-simpl</option>.</para>
8051
8052       <para>See also the <option>-funbox-strict-fields</option> flag,
8053       which essentially has the effect of adding
8054       <literal>{-#&nbsp;UNPACK&nbsp;#-}</literal> to every strict
8055       constructor field.</para>
8056     </sect2>
8057
8058     <sect2 id="source-pragma">
8059       <title>SOURCE pragma</title>
8060
8061       <indexterm><primary>SOURCE</primary></indexterm>
8062      <para>The <literal>{-# SOURCE #-}</literal> pragma is used only in <literal>import</literal> declarations,
8063      to break a module loop.  It is described in detail in <xref linkend="mutual-recursion"/>.
8064      </para>
8065 </sect2>
8066
8067 </sect1>
8068
8069 <!--  ======================= REWRITE RULES ======================== -->
8070
8071 <sect1 id="rewrite-rules">
8072 <title>Rewrite rules
8073
8074 <indexterm><primary>RULES pragma</primary></indexterm>
8075 <indexterm><primary>pragma, RULES</primary></indexterm>
8076 <indexterm><primary>rewrite rules</primary></indexterm></title>
8077
8078 <para>
8079 The programmer can specify rewrite rules as part of the source program
8080 (in a pragma).
8081 Here is an example:
8082
8083 <programlisting>
8084   {-# RULES
8085   "map/map"    forall f g xs.  map f (map g xs) = map (f.g) xs
8086     #-}
8087 </programlisting>
8088 </para>
8089 <para>
8090 Use the debug flag <option>-ddump-simpl-stats</option> to see what rules fired.
8091 If you need more information, then <option>-ddump-rule-firings</option> shows you
8092 each individual rule firing in detail.
8093 </para>
8094
8095 <sect2>
8096 <title>Syntax</title>
8097
8098 <para>
8099 From a syntactic point of view:
8100
8101 <itemizedlist>
8102
8103 <listitem>
8104 <para>
8105  There may be zero or more rules in a <literal>RULES</literal> pragma, separated by semicolons (which
8106  may be generated by the layout rule).
8107 </para>
8108 </listitem>
8109
8110 <listitem>
8111 <para>
8112 The layout rule applies in a pragma.
8113 Currently no new indentation level
8114 is set, so if you put several rules in single RULES pragma and wish to use layout to separate them,
8115 you must lay out the starting in the same column as the enclosing definitions.
8116 <programlisting>
8117   {-# RULES
8118   "map/map"    forall f g xs.  map f (map g xs) = map (f.g) xs
8119   "map/append" forall f xs ys. map f (xs ++ ys) = map f xs ++ map f ys
8120     #-}
8121 </programlisting>
8122 Furthermore, the closing <literal>#-}</literal>
8123 should start in a column to the right of the opening <literal>{-#</literal>.
8124 </para>
8125 </listitem>
8126
8127 <listitem>
8128 <para>
8129  Each rule has a name, enclosed in double quotes.  The name itself has
8130 no significance at all.  It is only used when reporting how many times the rule fired.
8131 </para>
8132 </listitem>
8133
8134 <listitem>
8135 <para>
8136 A rule may optionally have a phase-control number (see <xref linkend="phase-control"/>),
8137 immediately after the name of the rule.  Thus:
8138 <programlisting>
8139   {-# RULES
8140         "map/map" [2]  forall f g xs. map f (map g xs) = map (f.g) xs
8141     #-}
8142 </programlisting>
8143 The "[2]" means that the rule is active in Phase 2 and subsequent phases.  The inverse
8144 notation "[~2]" is also accepted, meaning that the rule is active up to, but not including,
8145 Phase 2.
8146 </para>
8147 </listitem>
8148
8149
8150
8151 <listitem>
8152 <para>
8153  Each variable mentioned in a rule must either be in scope (e.g. <function>map</function>),
8154 or bound by the <literal>forall</literal> (e.g. <function>f</function>, <function>g</function>, <function>xs</function>).  The variables bound by
8155 the <literal>forall</literal> are called the <emphasis>pattern</emphasis> variables.  They are separated
8156 by spaces, just like in a type <literal>forall</literal>.
8157 </para>
8158 </listitem>
8159 <listitem>
8160
8161 <para>
8162  A pattern variable may optionally have a type signature.
8163 If the type of the pattern variable is polymorphic, it <emphasis>must</emphasis> have a type signature.
8164 For example, here is the <literal>foldr/build</literal> rule:
8165
8166 <programlisting>
8167 "fold/build"  forall k z (g::forall b. (a->b->b) -> b -> b) .
8168               foldr k z (build g) = g k z
8169 </programlisting>
8170
8171 Since <function>g</function> has a polymorphic type, it must have a type signature.
8172
8173 </para>
8174 </listitem>
8175 <listitem>
8176
8177 <para>
8178 The left hand side of a rule must consist of a top-level variable applied
8179 to arbitrary expressions.  For example, this is <emphasis>not</emphasis> OK:
8180
8181 <programlisting>
8182 "wrong1"   forall e1 e2.  case True of { True -> e1; False -> e2 } = e1
8183 "wrong2"   forall f.      f True = True
8184 </programlisting>
8185
8186 In <literal>"wrong1"</literal>, the LHS is not an application; in <literal>"wrong2"</literal>, the LHS has a pattern variable
8187 in the head.
8188 </para>
8189 </listitem>
8190 <listitem>
8191
8192 <para>
8193  A rule does not need to be in the same module as (any of) the
8194 variables it mentions, though of course they need to be in scope.
8195 </para>
8196 </listitem>
8197 <listitem>
8198
8199 <para>
8200  All rules are implicitly exported from the module, and are therefore
8201 in force in any module that imports the module that defined the rule, directly
8202 or indirectly.  (That is, if A imports B, which imports C, then C's rules are
8203 in force when compiling A.)  The situation is very similar to that for instance
8204 declarations.
8205 </para>
8206 </listitem>
8207
8208 <listitem>
8209
8210 <para>
8211 Inside a RULE "<literal>forall</literal>" is treated as a keyword, regardless of
8212 any other flag settings.  Furthermore, inside a RULE, the language extension
8213 <option>-XScopedTypeVariables</option> is automatically enabled; see
8214 <xref linkend="scoped-type-variables"/>.
8215 </para>
8216 </listitem>
8217 <listitem>
8218
8219 <para>
8220 Like other pragmas, RULE pragmas are always checked for scope errors, and
8221 are typechecked. Typechecking means that the LHS and RHS of a rule are typechecked,
8222 and must have the same type.  However, rules are only <emphasis>enabled</emphasis>
8223 if the <option>-fenable-rewrite-rules</option> flag is
8224 on (see <xref linkend="rule-semantics"/>).
8225 </para>
8226 </listitem>
8227 </itemizedlist>
8228
8229 </para>
8230
8231 </sect2>
8232
8233 <sect2 id="rule-semantics">
8234 <title>Semantics</title>
8235
8236 <para>
8237 From a semantic point of view:
8238
8239 <itemizedlist>
8240 <listitem>
8241 <para>
8242 Rules are enabled (that is, used during optimisation)
8243 by the <option>-fenable-rewrite-rules</option> flag.
8244 This flag is implied by <option>-O</option>, and may be switched
8245 off (as usual) by <option>-fno-enable-rewrite-rules</option>.
8246 (NB: enabling <option>-fenable-rewrite-rules</option> without <option>-O</option>
8247 may not do what you expect, though, because without <option>-O</option> GHC
8248 ignores all optimisation information in interface files;
8249 see <option>-fignore-interface-pragmas</option>, <xref linkend="options-f"/>.)
8250 Note that <option>-fenable-rewrite-rules</option> is an <emphasis>optimisation</emphasis> flag, and
8251 has no effect on parsing or typechecking.
8252 </para>
8253 </listitem>
8254
8255 <listitem>
8256 <para>
8257  Rules are regarded as left-to-right rewrite rules.
8258 When GHC finds an expression that is a substitution instance of the LHS
8259 of a rule, it replaces the expression by the (appropriately-substituted) RHS.
8260 By "a substitution instance" we mean that the LHS can be made equal to the
8261 expression by substituting for the pattern variables.
8262
8263 </para>
8264 </listitem>
8265 <listitem>
8266
8267 <para>
8268  GHC makes absolutely no attempt to verify that the LHS and RHS
8269 of a rule have the same meaning.  That is undecidable in general, and
8270 infeasible in most interesting cases.  The responsibility is entirely the programmer's!
8271
8272 </para>
8273 </listitem>
8274 <listitem>
8275
8276 <para>
8277  GHC makes no attempt to make sure that the rules are confluent or
8278 terminating.  For example:
8279
8280 <programlisting>
8281   "loop"        forall x y.  f x y = f y x
8282 </programlisting>
8283
8284 This rule will cause the compiler to go into an infinite loop.
8285
8286 </para>
8287 </listitem>
8288 <listitem>
8289
8290 <para>
8291  If more than one rule matches a call, GHC will choose one arbitrarily to apply.
8292
8293 </para>
8294 </listitem>
8295 <listitem>
8296 <para>
8297  GHC currently uses a very simple, syntactic, matching algorithm
8298 for matching a rule LHS with an expression.  It seeks a substitution
8299 which makes the LHS and expression syntactically equal modulo alpha
8300 conversion.  The pattern (rule), but not the expression, is eta-expanded if
8301 necessary.  (Eta-expanding the expression can lead to laziness bugs.)
8302 But not beta conversion (that's called higher-order matching).
8303 </para>
8304
8305 <para>
8306 Matching is carried out on GHC's intermediate language, which includes
8307 type abstractions and applications.  So a rule only matches if the
8308 types match too.  See <xref linkend="rule-spec"/> below.
8309 </para>
8310 </listitem>
8311 <listitem>
8312
8313 <para>
8314  GHC keeps trying to apply the rules as it optimises the program.
8315 For example, consider:
8316
8317 <programlisting>
8318   let s = map f
8319       t = map g
8320   in
8321   s (t xs)
8322 </programlisting>
8323
8324 The expression <literal>s (t xs)</literal> does not match the rule <literal>"map/map"</literal>, but GHC
8325 will substitute for <varname>s</varname> and <varname>t</varname>, giving an expression which does match.
8326 If <varname>s</varname> or <varname>t</varname> was (a) used more than once, and (b) large or a redex, then it would
8327 not be substituted, and the rule would not fire.
8328
8329 </para>
8330 </listitem>
8331 </itemizedlist>
8332
8333 </para>
8334
8335 </sect2>
8336
8337 <sect2 id="conlike">
8338 <title>How rules interact with INLINE/NOINLINE and CONLIKE pragmas</title>
8339
8340 <para>
8341 Ordinary inlining happens at the same time as rule rewriting, which may lead to unexpected
8342 results.  Consider this (artificial) example
8343 <programlisting>
8344 f x = x
8345 g y = f y
8346 h z = g True
8347
8348 {-# RULES "f" f True = False #-}
8349 </programlisting>
8350 Since <literal>f</literal>'s right-hand side is small, it is inlined into <literal>g</literal>,
8351 to give
8352 <programlisting>
8353 g y = y
8354 </programlisting>
8355 Now <literal>g</literal> is inlined into <literal>h</literal>, but <literal>f</literal>'s RULE has
8356 no chance to fire.
8357 If instead GHC had first inlined <literal>g</literal> into <literal>h</literal> then there
8358 would have been a better chance that <literal>f</literal>'s RULE might fire.
8359 </para>
8360 <para>
8361 The way to get predictable behaviour is to use a NOINLINE
8362 pragma, or an INLINE[<replaceable>phase</replaceable>] pragma, on <literal>f</literal>, to ensure
8363 that it is not inlined until its RULEs have had a chance to fire.
8364 </para>
8365 <para>
8366 GHC is very cautious about duplicating work.  For example, consider
8367 <programlisting>
8368 f k z xs = let xs = build g
8369            in ...(foldr k z xs)...sum xs...
8370 {-# RULES "foldr/build" forall k z g. foldr k z (build g) = g k z #-}
8371 </programlisting>
8372 Since <literal>xs</literal> is used twice, GHC does not fire the foldr/build rule.  Rightly
8373 so, because it might take a lot of work to compute <literal>xs</literal>, which would be
8374 duplicated if the rule fired.
8375 </para>
8376 <para>
8377 Sometimes, however, this approach is over-cautious, and we <emphasis>do</emphasis> want the
8378 rule to fire, even though doing so would duplicate redex.  There is no way that GHC can work out
8379 when this is a good idea, so we provide the CONLIKE pragma to declare it, thus:
8380 <programlisting>
8381 {-# INLINE[1] CONLIKE f #-}
8382 f x = <replaceable>blah</replaceable>
8383 </programlisting>
8384 CONLIKE is a modifier to an INLINE or NOINLINE pragam.  It specifies that an application
8385 of f to one argument (in general, the number of arguments to the left of the '=' sign)
8386 should be considered cheap enough to duplicate, if such a duplication would make rule
8387 fire.  (The name "CONLIKE" is short for "constructor-like", because constructors certainly
8388 have such a property.)
8389 The CONLIKE pragam is a modifier to INLINE/NOINLINE because it really only makes sense to match
8390 <literal>f</literal> on the LHS of a rule if you are sure that <literal>f</literal> is
8391 not going to be inlined before the rule has a chance to fire.
8392 </para>
8393 </sect2>
8394
8395 <sect2>
8396 <title>List fusion</title>
8397
8398 <para>
8399 The RULES mechanism is used to implement fusion (deforestation) of common list functions.
8400 If a "good consumer" consumes an intermediate list constructed by a "good producer", the
8401 intermediate list should be eliminated entirely.
8402 </para>
8403
8404 <para>
8405 The following are good producers:
8406
8407 <itemizedlist>
8408 <listitem>
8409
8410 <para>
8411  List comprehensions
8412 </para>
8413 </listitem>
8414 <listitem>
8415
8416 <para>
8417  Enumerations of <literal>Int</literal> and <literal>Char</literal> (e.g. <literal>['a'..'z']</literal>).
8418 </para>
8419 </listitem>
8420 <listitem>
8421
8422 <para>
8423  Explicit lists (e.g. <literal>[True, False]</literal>)
8424 </para>
8425 </listitem>
8426 <listitem>
8427
8428 <para>
8429  The cons constructor (e.g <literal>3:4:[]</literal>)
8430 </para>
8431 </listitem>
8432 <listitem>
8433
8434 <para>
8435  <function>++</function>
8436 </para>
8437 </listitem>
8438
8439 <listitem>
8440 <para>
8441  <function>map</function>
8442 </para>
8443 </listitem>
8444
8445 <listitem>
8446 <para>
8447 <function>take</function>, <function>filter</function>
8448 </para>
8449 </listitem>
8450 <listitem>
8451
8452 <para>
8453  <function>iterate</function>, <function>repeat</function>
8454 </para>
8455 </listitem>
8456 <listitem>
8457
8458 <para>
8459  <function>zip</function>, <function>zipWith</function>
8460 </para>
8461 </listitem>
8462
8463 </itemizedlist>
8464
8465 </para>
8466
8467 <para>
8468 The following are good consumers:
8469
8470 <itemizedlist>
8471 <listitem>
8472
8473 <para>
8474  List comprehensions
8475 </para>
8476 </listitem>
8477 <listitem>
8478
8479 <para>
8480  <function>array</function> (on its second argument)
8481 </para>
8482 </listitem>
8483 <listitem>
8484
8485 <para>
8486  <function>++</function> (on its first argument)
8487 </para>
8488 </listitem>
8489
8490 <listitem>
8491 <para>
8492  <function>foldr</function>
8493 </para>
8494 </listitem>
8495
8496 <listitem>
8497 <para>
8498  <function>map</function>
8499 </para>
8500 </listitem>
8501 <listitem>
8502
8503 <para>
8504 <function>take</function>, <function>filter</function>
8505 </para>
8506 </listitem>
8507 <listitem>
8508
8509 <para>
8510  <function>concat</function>
8511 </para>
8512 </listitem>
8513 <listitem>
8514
8515 <para>
8516  <function>unzip</function>, <function>unzip2</function>, <function>unzip3</function>, <function>unzip4</function>
8517 </para>
8518 </listitem>
8519 <listitem>
8520
8521 <para>
8522  <function>zip</function>, <function>zipWith</function> (but on one argument only; if both are good producers, <function>zip</function>
8523 will fuse with one but not the other)
8524 </para>
8525 </listitem>
8526 <listitem>
8527
8528 <para>
8529  <function>partition</function>
8530 </para>
8531 </listitem>
8532 <listitem>
8533
8534 <para>
8535  <function>head</function>
8536 </para>
8537 </listitem>
8538 <listitem>
8539
8540 <para>
8541  <function>and</function>, <function>or</function>, <function>any</function>, <function>all</function>
8542 </para>
8543 </listitem>
8544 <listitem>
8545
8546 <para>
8547  <function>sequence&lowbar;</function>
8548 </para>
8549 </listitem>
8550 <listitem>
8551
8552 <para>
8553  <function>msum</function>
8554 </para>
8555 </listitem>
8556 <listitem>
8557
8558 <para>
8559  <function>sortBy</function>
8560 </para>
8561 </listitem>
8562
8563 </itemizedlist>
8564
8565 </para>
8566
8567  <para>
8568 So, for example, the following should generate no intermediate lists:
8569
8570 <programlisting>
8571 array (1,10) [(i,i*i) | i &#60;- map (+ 1) [0..9]]
8572 </programlisting>
8573
8574 </para>
8575
8576 <para>
8577 This list could readily be extended; if there are Prelude functions that you use
8578 a lot which are not included, please tell us.
8579 </para>
8580
8581 <para>
8582 If you want to write your own good consumers or producers, look at the
8583 Prelude definitions of the above functions to see how to do so.
8584 </para>
8585
8586 </sect2>
8587
8588 <sect2 id="rule-spec">
8589 <title>Specialisation
8590 </title>
8591
8592 <para>
8593 Rewrite rules can be used to get the same effect as a feature
8594 present in earlier versions of GHC.
8595 For example, suppose that:
8596
8597 <programlisting>
8598 genericLookup :: Ord a => Table a b   -> a   -> b
8599 intLookup     ::          Table Int b -> Int -> b
8600 </programlisting>
8601
8602 where <function>intLookup</function> is an implementation of
8603 <function>genericLookup</function> that works very fast for
8604 keys of type <literal>Int</literal>.  You might wish
8605 to tell GHC to use <function>intLookup</function> instead of
8606 <function>genericLookup</function> whenever the latter was called with
8607 type <literal>Table Int b -&gt; Int -&gt; b</literal>.
8608 It used to be possible to write
8609
8610 <programlisting>
8611 {-# SPECIALIZE genericLookup :: Table Int b -> Int -> b = intLookup #-}
8612 </programlisting>
8613
8614 This feature is no longer in GHC, but rewrite rules let you do the same thing:
8615
8616 <programlisting>
8617 {-# RULES "genericLookup/Int" genericLookup = intLookup #-}
8618 </programlisting>
8619
8620 This slightly odd-looking rule instructs GHC to replace
8621 <function>genericLookup</function> by <function>intLookup</function>
8622 <emphasis>whenever the types match</emphasis>.
8623 What is more, this rule does not need to be in the same
8624 file as <function>genericLookup</function>, unlike the
8625 <literal>SPECIALIZE</literal> pragmas which currently do (so that they
8626 have an original definition available to specialise).
8627 </para>
8628
8629 <para>It is <emphasis>Your Responsibility</emphasis> to make sure that
8630 <function>intLookup</function> really behaves as a specialised version
8631 of <function>genericLookup</function>!!!</para>
8632
8633 <para>An example in which using <literal>RULES</literal> for
8634 specialisation will Win Big:
8635
8636 <programlisting>
8637 toDouble :: Real a => a -> Double
8638 toDouble = fromRational . toRational
8639
8640 {-# RULES "toDouble/Int" toDouble = i2d #-}
8641 i2d (I# i) = D# (int2Double# i) -- uses Glasgow prim-op directly
8642 </programlisting>
8643
8644 The <function>i2d</function> function is virtually one machine
8645 instruction; the default conversion&mdash;via an intermediate
8646 <literal>Rational</literal>&mdash;is obscenely expensive by
8647 comparison.
8648 </para>
8649
8650 </sect2>
8651
8652 <sect2 id="controlling-rules">
8653 <title>Controlling what's going on in rewrite rules</title>
8654
8655 <para>
8656
8657 <itemizedlist>
8658 <listitem>
8659
8660 <para>
8661 Use <option>-ddump-rules</option> to see the rules that are defined
8662 <emphasis>in this module</emphasis>.
8663 This includes rules generated by the specialisation pass, but excludes
8664 rules imported from other modules.
8665 </para>
8666 </listitem>
8667
8668 <listitem>
8669 <para>
8670  Use <option>-ddump-simpl-stats</option> to see what rules are being fired.
8671 If you add <option>-dppr-debug</option> you get a more detailed listing.
8672 </para>
8673 </listitem>
8674
8675 <listitem>
8676 <para>
8677  Use <option>-ddump-rule-firings</option> to see in great detail what rules are being fired.
8678 If you add <option>-dppr-debug</option> you get a still more detailed listing.
8679 </para>
8680 </listitem>
8681
8682 <listitem>
8683 <para>
8684  The definition of (say) <function>build</function> in <filename>GHC/Base.lhs</filename> looks like this:
8685
8686 <programlisting>
8687         build   :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
8688         {-# INLINE build #-}
8689         build g = g (:) []
8690 </programlisting>
8691
8692 Notice the <literal>INLINE</literal>!  That prevents <literal>(:)</literal> from being inlined when compiling
8693 <literal>PrelBase</literal>, so that an importing module will &ldquo;see&rdquo; the <literal>(:)</literal>, and can
8694 match it on the LHS of a rule.  <literal>INLINE</literal> prevents any inlining happening
8695 in the RHS of the <literal>INLINE</literal> thing.  I regret the delicacy of this.
8696
8697 </para>
8698 </listitem>
8699 <listitem>
8700
8701 <para>
8702  In <filename>libraries/base/GHC/Base.lhs</filename> look at the rules for <function>map</function> to
8703 see how to write rules that will do fusion and yet give an efficient
8704 program even if fusion doesn't happen.  More rules in <filename>GHC/List.lhs</filename>.
8705 </para>
8706 </listitem>
8707
8708 </itemizedlist>
8709
8710 </para>
8711
8712 </sect2>
8713
8714 <sect2 id="core-pragma">
8715   <title>CORE pragma</title>
8716
8717   <indexterm><primary>CORE pragma</primary></indexterm>
8718   <indexterm><primary>pragma, CORE</primary></indexterm>
8719   <indexterm><primary>core, annotation</primary></indexterm>
8720
8721 <para>
8722   The external core format supports <quote>Note</quote> annotations;
8723   the <literal>CORE</literal> pragma gives a way to specify what these
8724   should be in your Haskell source code.  Syntactically, core
8725   annotations are attached to expressions and take a Haskell string
8726   literal as an argument.  The following function definition shows an
8727   example:
8728
8729 <programlisting>
8730 f x = ({-# CORE "foo" #-} show) ({-# CORE "bar" #-} x)
8731 </programlisting>
8732
8733   Semantically, this is equivalent to:
8734
8735 <programlisting>
8736 g x = show x
8737 </programlisting>
8738 </para>
8739
8740 <para>
8741   However, when external core is generated (via
8742   <option>-fext-core</option>), there will be Notes attached to the
8743   expressions <function>show</function> and <varname>x</varname>.
8744   The core function declaration for <function>f</function> is:
8745 </para>
8746
8747 <programlisting>
8748   f :: %forall a . GHCziShow.ZCTShow a ->
8749                    a -> GHCziBase.ZMZN GHCziBase.Char =
8750     \ @ a (zddShow::GHCziShow.ZCTShow a) (eta::a) ->
8751         (%note "foo"
8752          %case zddShow %of (tpl::GHCziShow.ZCTShow a)
8753            {GHCziShow.ZCDShow
8754             (tpl1::GHCziBase.Int ->
8755                    a ->
8756                    GHCziBase.ZMZN GHCziBase.Char -> GHCziBase.ZMZN GHCziBase.Cha
8757 r)
8758             (tpl2::a -> GHCziBase.ZMZN GHCziBase.Char)
8759             (tpl3::GHCziBase.ZMZN a ->
8760                    GHCziBase.ZMZN GHCziBase.Char -> GHCziBase.ZMZN GHCziBase.Cha
8761 r) ->
8762               tpl2})
8763         (%note "bar"
8764          eta);
8765 </programlisting>
8766
8767 <para>
8768   Here, we can see that the function <function>show</function> (which
8769   has been expanded out to a case expression over the Show dictionary)
8770   has a <literal>%note</literal> attached to it, as does the
8771   expression <varname>eta</varname> (which used to be called
8772   <varname>x</varname>).
8773 </para>
8774
8775 </sect2>
8776
8777 </sect1>
8778
8779 <sect1 id="special-ids">
8780 <title>Special built-in functions</title>
8781 <para>GHC has a few built-in functions with special behaviour.  These
8782 are now described in the module <ulink
8783 url="&libraryGhcPrimLocation;/GHC-Prim.html"><literal>GHC.Prim</literal></ulink>
8784 in the library documentation.</para>
8785 </sect1>
8786
8787
8788 <sect1 id="generic-classes">
8789 <title>Generic classes</title>
8790
8791 <para>
8792 The ideas behind this extension are described in detail in "Derivable type classes",
8793 Ralf Hinze and Simon Peyton Jones, Haskell Workshop, Montreal Sept 2000, pp94-105.
8794 An example will give the idea:
8795 </para>
8796
8797 <programlisting>
8798   import Generics
8799
8800   class Bin a where
8801     toBin   :: a -> [Int]
8802     fromBin :: [Int] -> (a, [Int])
8803
8804     toBin {| Unit |}    Unit      = []
8805     toBin {| a :+: b |} (Inl x)   = 0 : toBin x
8806     toBin {| a :+: b |} (Inr y)   = 1 : toBin y
8807     toBin {| a :*: b |} (x :*: y) = toBin x ++ toBin y
8808
8809     fromBin {| Unit |}    bs      = (Unit, bs)
8810     fromBin {| a :+: b |} (0:bs)  = (Inl x, bs')    where (x,bs') = fromBin bs
8811     fromBin {| a :+: b |} (1:bs)  = (Inr y, bs')    where (y,bs') = fromBin bs
8812     fromBin {| a :*: b |} bs      = (x :*: y, bs'') where (x,bs' ) = fromBin bs
8813                                                           (y,bs'') = fromBin bs'
8814 </programlisting>
8815 <para>
8816 This class declaration explains how <literal>toBin</literal> and <literal>fromBin</literal>
8817 work for arbitrary data types.  They do so by giving cases for unit, product, and sum,
8818 which are defined thus in the library module <literal>Generics</literal>:
8819 </para>
8820 <programlisting>
8821   data Unit    = Unit
8822   data a :+: b = Inl a | Inr b
8823   data a :*: b = a :*: b
8824 </programlisting>
8825 <para>
8826 Now you can make a data type into an instance of Bin like this:
8827 <programlisting>
8828   instance (Bin a, Bin b) => Bin (a,b)
8829   instance Bin a => Bin [a]
8830 </programlisting>
8831 That is, just leave off the "where" clause.  Of course, you can put in the
8832 where clause and over-ride whichever methods you please.
8833 </para>
8834
8835     <sect2>
8836       <title> Using generics </title>
8837       <para>To use generics you need to</para>
8838       <itemizedlist>
8839         <listitem>
8840           <para>Use the flags <option>-fglasgow-exts</option> (to enable the extra syntax),
8841                 <option>-XGenerics</option> (to generate extra per-data-type code),
8842                 and <option>-package lang</option> (to make the <literal>Generics</literal> library
8843                 available.  </para>
8844         </listitem>
8845         <listitem>
8846           <para>Import the module <literal>Generics</literal> from the
8847           <literal>lang</literal> package.  This import brings into
8848           scope the data types <literal>Unit</literal>,
8849           <literal>:*:</literal>, and <literal>:+:</literal>.  (You
8850           don't need this import if you don't mention these types
8851           explicitly; for example, if you are simply giving instance
8852           declarations.)</para>
8853         </listitem>
8854       </itemizedlist>
8855     </sect2>
8856
8857 <sect2> <title> Changes wrt the paper </title>
8858 <para>
8859 Note that the type constructors <literal>:+:</literal> and <literal>:*:</literal>
8860 can be written infix (indeed, you can now use
8861 any operator starting in a colon as an infix type constructor).  Also note that
8862 the type constructors are not exactly as in the paper (Unit instead of 1, etc).
8863 Finally, note that the syntax of the type patterns in the class declaration
8864 uses "<literal>{|</literal>" and "<literal>|}</literal>" brackets; curly braces
8865 alone would ambiguous when they appear on right hand sides (an extension we
8866 anticipate wanting).
8867 </para>
8868 </sect2>
8869
8870 <sect2> <title>Terminology and restrictions</title>
8871 <para>
8872 Terminology.  A "generic default method" in a class declaration
8873 is one that is defined using type patterns as above.
8874 A "polymorphic default method" is a default method defined as in Haskell 98.
8875 A "generic class declaration" is a class declaration with at least one
8876 generic default method.
8877 </para>
8878
8879 <para>
8880 Restrictions:
8881 <itemizedlist>
8882 <listitem>
8883 <para>
8884 Alas, we do not yet implement the stuff about constructor names and
8885 field labels.
8886 </para>
8887 </listitem>
8888
8889 <listitem>
8890 <para>
8891 A generic class can have only one parameter; you can't have a generic
8892 multi-parameter class.
8893 </para>
8894 </listitem>
8895
8896 <listitem>
8897 <para>
8898 A default method must be defined entirely using type patterns, or entirely
8899 without.  So this is illegal:
8900 <programlisting>
8901   class Foo a where
8902     op :: a -> (a, Bool)
8903     op {| Unit |} Unit = (Unit, True)
8904     op x               = (x,    False)
8905 </programlisting>
8906 However it is perfectly OK for some methods of a generic class to have
8907 generic default methods and others to have polymorphic default methods.
8908 </para>
8909 </listitem>
8910
8911 <listitem>
8912 <para>
8913 The type variable(s) in the type pattern for a generic method declaration
8914 scope over the right hand side.  So this is legal (note the use of the type variable ``p'' in a type signature on the right hand side:
8915 <programlisting>
8916   class Foo a where
8917     op :: a -> Bool
8918     op {| p :*: q |} (x :*: y) = op (x :: p)
8919     ...
8920 </programlisting>
8921 </para>
8922 </listitem>
8923
8924 <listitem>
8925 <para>
8926 The type patterns in a generic default method must take one of the forms:
8927 <programlisting>
8928        a :+: b
8929        a :*: b
8930        Unit
8931 </programlisting>
8932 where "a" and "b" are type variables.  Furthermore, all the type patterns for
8933 a single type constructor (<literal>:*:</literal>, say) must be identical; they
8934 must use the same type variables.  So this is illegal:
8935 <programlisting>
8936   class Foo a where
8937     op :: a -> Bool
8938     op {| a :+: b |} (Inl x) = True
8939     op {| p :+: q |} (Inr y) = False
8940 </programlisting>
8941 The type patterns must be identical, even in equations for different methods of the class.
8942 So this too is illegal:
8943 <programlisting>
8944   class Foo a where
8945     op1 :: a -> Bool
8946     op1 {| a :*: b |} (x :*: y) = True
8947
8948     op2 :: a -> Bool
8949     op2 {| p :*: q |} (x :*: y) = False
8950 </programlisting>
8951 (The reason for this restriction is that we gather all the equations for a particular type constructor
8952 into a single generic instance declaration.)
8953 </para>
8954 </listitem>
8955
8956 <listitem>
8957 <para>
8958 A generic method declaration must give a case for each of the three type constructors.
8959 </para>
8960 </listitem>
8961
8962 <listitem>
8963 <para>
8964 The type for a generic method can be built only from:
8965   <itemizedlist>
8966   <listitem> <para> Function arrows </para> </listitem>
8967   <listitem> <para> Type variables </para> </listitem>
8968   <listitem> <para> Tuples </para> </listitem>
8969   <listitem> <para> Arbitrary types not involving type variables </para> </listitem>
8970   </itemizedlist>
8971 Here are some example type signatures for generic methods:
8972 <programlisting>
8973     op1 :: a -> Bool
8974     op2 :: Bool -> (a,Bool)
8975     op3 :: [Int] -> a -> a
8976     op4 :: [a] -> Bool
8977 </programlisting>
8978 Here, op1, op2, op3 are OK, but op4 is rejected, because it has a type variable
8979 inside a list.
8980 </para>
8981 <para>
8982 This restriction is an implementation restriction: we just haven't got around to
8983 implementing the necessary bidirectional maps over arbitrary type constructors.
8984 It would be relatively easy to add specific type constructors, such as Maybe and list,
8985 to the ones that are allowed.</para>
8986 </listitem>
8987
8988 <listitem>
8989 <para>
8990 In an instance declaration for a generic class, the idea is that the compiler
8991 will fill in the methods for you, based on the generic templates.  However it can only
8992 do so if
8993   <itemizedlist>
8994   <listitem>
8995   <para>
8996   The instance type is simple (a type constructor applied to type variables, as in Haskell 98).
8997   </para>
8998   </listitem>
8999   <listitem>
9000   <para>
9001   No constructor of the instance type has unboxed fields.
9002   </para>
9003   </listitem>
9004   </itemizedlist>
9005 (Of course, these things can only arise if you are already using GHC extensions.)
9006 However, you can still give an instance declarations for types which break these rules,
9007 provided you give explicit code to override any generic default methods.
9008 </para>
9009 </listitem>
9010
9011 </itemizedlist>
9012 </para>
9013
9014 <para>
9015 The option <option>-ddump-deriv</option> dumps incomprehensible stuff giving details of
9016 what the compiler does with generic declarations.
9017 </para>
9018
9019 </sect2>
9020
9021 <sect2> <title> Another example </title>
9022 <para>
9023 Just to finish with, here's another example I rather like:
9024 <programlisting>
9025   class Tag a where
9026     nCons :: a -> Int
9027     nCons {| Unit |}    _ = 1
9028     nCons {| a :*: b |} _ = 1
9029     nCons {| a :+: b |} _ = nCons (bot::a) + nCons (bot::b)
9030
9031     tag :: a -> Int
9032     tag {| Unit |}    _       = 1
9033     tag {| a :*: b |} _       = 1
9034     tag {| a :+: b |} (Inl x) = tag x
9035     tag {| a :+: b |} (Inr y) = nCons (bot::a) + tag y
9036 </programlisting>
9037 </para>
9038 </sect2>
9039 </sect1>
9040
9041 <sect1 id="monomorphism">
9042 <title>Control over monomorphism</title>
9043
9044 <para>GHC supports two flags that control the way in which generalisation is
9045 carried out at let and where bindings.
9046 </para>
9047
9048 <sect2>
9049 <title>Switching off the dreaded Monomorphism Restriction</title>
9050           <indexterm><primary><option>-XNoMonomorphismRestriction</option></primary></indexterm>
9051
9052 <para>Haskell's monomorphism restriction (see
9053 <ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.5">Section
9054 4.5.5</ulink>
9055 of the Haskell Report)
9056 can be completely switched off by
9057 <option>-XNoMonomorphismRestriction</option>.
9058 </para>
9059 </sect2>
9060
9061 <sect2>
9062 <title>Monomorphic pattern bindings</title>
9063           <indexterm><primary><option>-XNoMonoPatBinds</option></primary></indexterm>
9064           <indexterm><primary><option>-XMonoPatBinds</option></primary></indexterm>
9065
9066           <para> As an experimental change, we are exploring the possibility of
9067           making pattern bindings monomorphic; that is, not generalised at all.
9068             A pattern binding is a binding whose LHS has no function arguments,
9069             and is not a simple variable.  For example:
9070 <programlisting>
9071   f x = x                    -- Not a pattern binding
9072   f = \x -> x                -- Not a pattern binding
9073   f :: Int -> Int = \x -> x  -- Not a pattern binding
9074
9075   (g,h) = e                  -- A pattern binding
9076   (f) = e                    -- A pattern binding
9077   [x] = e                    -- A pattern binding
9078 </programlisting>
9079 Experimentally, GHC now makes pattern bindings monomorphic <emphasis>by
9080 default</emphasis>.  Use <option>-XNoMonoPatBinds</option> to recover the
9081 standard behaviour.
9082 </para>
9083 </sect2>
9084 </sect1>
9085
9086
9087
9088 <!-- Emacs stuff:
9089      ;;; Local Variables: ***
9090      ;;; mode: xml ***
9091      ;;; sgml-parent-document: ("users_guide.xml" "book" "chapter" "sect1") ***
9092      ;;; ispell-local-dictionary: "british" ***
9093      ;;; End: ***
9094  -->
9095