1 <?xml version="1.0" encoding="iso-8859-1"?>
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.
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 “stuck”
15 on performance because of the implementation costs of Haskell's
16 “high-level” features—you can always code
17 “under” them. In an extreme case, you can write all your
18 time-critical code in C, and then just glue it together with Haskell!
22 Before you get too carried away working at the lowest level (e.g.,
23 sloshing <literal>MutableByteArray#</literal>s around your
24 program), you may wish to check if there are libraries that provide a
25 “Haskellised veneer” 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.
30 <!-- LANGUAGE OPTIONS -->
31 <sect1 id="options-language">
32 <title>Language options</title>
34 <indexterm><primary>language</primary><secondary>option</secondary>
36 <indexterm><primary>options</primary><secondary>language</secondary>
38 <indexterm><primary>extensions</primary><secondary>options controlling</secondary>
41 <para>The language option flags control what variation of the language are
42 permitted. Leaving out all of them gives you standard Haskell
45 <para>Language options can be controlled in two ways:
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>
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>
54 </itemizedlist></para>
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>
98 <!-- UNBOXED TYPES AND PRIMITIVE OPERATIONS -->
99 <sect1 id="primitives">
100 <title>Unboxed types and primitive operations</title>
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
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>.)
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 "#", and to mention such
120 names you need the <option>-XMagicHash</option> extension (<xref linkend="magic-hash"/>).
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>
127 <sect2 id="glasgow-unboxed">
132 <indexterm><primary>Unboxed types (Glasgow extension)</primary></indexterm>
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.
144 Unboxed types correspond to the “raw machine” types you
145 would use in C: <literal>Int#</literal> (long int),
146 <literal>Double#</literal> (double), <literal>Addr#</literal>
147 (void *), etc. The <emphasis>primitive operations</emphasis>
148 (PrimOps) on these types are what you might expect; e.g.,
149 <literal>(+#)</literal> is addition on
150 <literal>Int#</literal>s, and is the machine-addition that we all
151 know and love—usually one instruction.
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>#</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>.
166 Primitive values are often represented by a simple bit-pattern, such
167 as <literal>Int#</literal>, <literal>Float#</literal>,
168 <literal>Double#</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#</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…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 “standard”
180 counterpart—we saw a threefold speedup on one example.
184 There are some restrictions on the use of primitive types:
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#]</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#</literal> for instance).
200 <listitem><para> You cannot define a newtype whose representation type
201 (the argument type of the data constructor) is an unboxed type. Thus,
207 <listitem><para> You cannot bind a variable with an unboxed type
208 in a <emphasis>top-level</emphasis> binding.
210 <listitem><para> You cannot bind a variable with an unboxed type
211 in a <emphasis>recursive</emphasis> binding.
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:
217 data Foo = Foo Int Int#
219 f x = let (Foo a b, w) = ..rhs.. in ..body..
223 data Foo = Foo Int Int#
225 f x = let !(Foo a b, w) = ..rhs.. in ..body..
227 since <literal>b</literal> has type <literal>Int#</literal>.
235 <sect2 id="unboxed-tuples">
236 <title>Unboxed Tuples
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:
254 where <literal>e_1..e_n</literal> are expressions of any
255 type (primitive or non-primitive). The type of an unboxed tuple looks
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
267 In particular, the <literal>IO</literal> and <literal>ST</literal> monads use unboxed
268 tuples to avoid unnecessary allocation during sequences of operations.
272 There are some pretty stringent restrictions on the use of unboxed tuples:
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.
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:
291 data Foo = Foo (# Int, Int #)
293 f :: (# Int, Int #) -> (# Int, Int #)
296 g :: (# Int, Int #) -> Int
299 h x = let y = (# x,x #) in ...
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:
309 f x y = (# x+1, y-1 #)
310 g x = case f x x of { (# a, b #) -> a + b }
312 You can have an unboxed tuple in a pattern binding, thus
314 f x = let (# p,q #) = h x in ..body..
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:
320 f x = let t = case h x o f{ (# p,q #) -> (p,q)
325 Indeed, the bindings can even be recursive.
332 <!-- ====================== SYNTACTIC EXTENSIONS ======================= -->
334 <sect1 id="syntax-extns">
335 <title>Syntactic extensions</title>
337 <sect2 id="unicode-syntax">
338 <title>Unicode syntax</title>
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>
345 <tgroup cols="2" align="left" colsep="1" rowsep="1">
349 <entry>Unicode alternative</entry>
350 <entry>Code point</entry>
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.
365 <entry><literal>::</literal></entry>
366 <entry>::</entry> <!-- no special char, apparently -->
367 <entry>0x2237</entry>
368 <entry>PROPORTION</entry>
373 <entry><literal>=></literal></entry>
374 <entry>⇒</entry>
375 <entry>0x21D2</entry>
376 <entry>RIGHTWARDS DOUBLE ARROW</entry>
381 <entry><literal>forall</literal></entry>
382 <entry>∀</entry>
383 <entry>0x2200</entry>
384 <entry>FOR ALL</entry>
389 <entry><literal>-></literal></entry>
390 <entry>→</entry>
391 <entry>0x2192</entry>
392 <entry>RIGHTWARDS ARROW</entry>
397 <entry><literal><-</literal></entry>
398 <entry>←</entry>
399 <entry>0x2190</entry>
400 <entry>LEFTWARDS ARROW</entry>
406 <entry>…</entry>
407 <entry>0x22EF</entry>
408 <entry>MIDLINE HORIZONTAL ELLIPSIS</entry>
415 <entry>↢</entry>
416 <entry>0x2919</entry>
417 <entry>LEFTWARDS ARROW-TAIL</entry>
424 <entry>↣</entry>
425 <entry>0x291A</entry>
426 <entry>RIGHTWARDS ARROW-TAIL</entry>
432 <entry>-<<</entry>
434 <entry>0x291B</entry>
435 <entry>LEFTWARDS DOUBLE ARROW-TAIL</entry>
441 <entry>>>-</entry>
443 <entry>0x291C</entry>
444 <entry>RIGHTWARDS DOUBLE ARROW-TAIL</entry>
451 <entry>★</entry>
452 <entry>0x2605</entry>
453 <entry>BLACK STAR</entry>
461 <sect2 id="magic-hash">
462 <title>The magic hash</title>
463 <para>The language extension <option>-XMagicHash</option> allows "#" as a
464 postfix modifier to identifiers. Thus, "x#" is a valid variable, and "T#" is
465 a valid type constructor or data constructor.</para>
467 <para>The hash sign does not change sematics at all. We tend to use variable
468 names ending in "#" for unboxed values or types (e.g. <literal>Int#</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#</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#</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"/>):
478 <listitem><para> <literal>'x'#</literal> has type <literal>Char#</literal></para> </listitem>
479 <listitem><para> <literal>"foo"#</literal> has type <literal>Addr#</literal></para> </listitem>
480 <listitem><para> <literal>3#</literal> has type <literal>Int#</literal>. In general,
481 any Haskell 98 integer lexeme followed by a <literal>#</literal> is an <literal>Int#</literal> literal, e.g.
482 <literal>-0x3A#</literal> as well as <literal>32#</literal></para>.</listitem>
483 <listitem><para> <literal>3##</literal> has type <literal>Word#</literal>. In general,
484 any non-negative Haskell 98 integer lexeme followed by <literal>##</literal>
485 is a <literal>Word#</literal>. </para> </listitem>
486 <listitem><para> <literal>3.2#</literal> has type <literal>Float#</literal>.</para> </listitem>
487 <listitem><para> <literal>3.2##</literal> has type <literal>Double#</literal></para> </listitem>
492 <sect2 id="new-qualified-operators">
493 <title>New qualified operator syntax</title>
495 <para>A new syntax for referencing qualified operators is
496 planned to be introduced by Haskell', and is enabled in GHC
498 the <option>-XNewQualifiedOperators</option><indexterm><primary><option>-XNewQualifiedOperators</option></primary></indexterm>
499 option. In the new syntax, the prefix form of a qualified
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>.
510 add x y = Prelude.(+) x y
511 subtract y = (`Prelude.(-)` y)
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 ‘<literal>.</literal>‘
520 from module <literal>Monday</literal>.</para>
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>
529 <!-- ====================== HIERARCHICAL MODULES ======================= -->
532 <sect2 id="hierarchical-modules">
533 <title>Hierarchical Modules</title>
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>‘.’</literal>. This is also known as the
538 “hierarchical module namespace” extension, because
539 it extends the normally flat Haskell module namespace into a
540 more flexible hierarchy of modules.</para>
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
551 <programlisting>module A.B.C</programlisting>
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>
559 import qualified Control.Monad.ST.Strict as ST
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>
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
571 url="http://hackage.haskell.org/packages/hackage.html">HackageDB</ulink>.</para>
574 <!-- ====================== PATTERN GUARDS ======================= -->
576 <sect2 id="pattern-guards">
577 <title>Pattern guards</title>
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.)
585 Suppose we have an abstract data type of finite maps, with a
589 lookup :: FiniteMap -> Int -> Maybe Int
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:
597 clunky env var1 var2 | ok1 && ok2 = val1 + val2
598 | otherwise = var1 + var2
609 The auxiliary functions are
613 maybeToBool :: Maybe a -> Bool
614 maybeToBool (Just x) = True
615 maybeToBool Nothing = False
617 expectJust :: Maybe a -> a
618 expectJust (Just x) = x
619 expectJust Nothing = error "Unexpected Nothing"
623 What is <function>clunky</function> doing? The guard <literal>ok1 &&
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.
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:
640 clunky env var1 var2 = case lookup env var1 of
642 Just val1 -> case lookup env var2 of
644 Just val2 -> val1 + val2
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.
661 Here is how I would write clunky:
666 | Just val1 <- lookup env var1
667 , Just val2 <- lookup env var2
669 ...other equations for clunky...
673 The semantics should be clear enough. The qualifiers are matched in order.
674 For a <literal><-</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><-</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.
686 Just as with list comprehensions, boolean expressions can be freely mixed
687 with among the pattern guards. For example:
698 Haskell's current guards therefore emerge as a special case, in which the
699 qualifier list has just one element, a boolean expression.
703 <!-- ===================== View patterns =================== -->
705 <sect2 id="view-patterns">
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
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
729 view :: Type -> TypeView
731 -- additional operations for constructing Typ's ...
734 The representation of Typ is held abstract, permitting implementations
735 to use a fancy representation (e.g., hash-consing to manage sharing).
737 Without view patterns, using this signature a little inconvenient:
739 size :: Typ -> Integer
740 size t = case view t of
742 Arrow t1 t2 -> size t1 + size t2
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.
751 View patterns permit calling the view function inside the pattern and
752 matching against the result:
754 size (view -> Unit) = 1
755 size (view -> Arrow t1 t2) = size t1 + size t2
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
768 The semantics of a pattern <literal>(</literal>
769 <replaceable>exp</replaceable> <literal>-></literal>
770 <replaceable>pat</replaceable> <literal>)</literal> are as follows:
776 <para>The variables bound by the view pattern are the variables bound by
777 <replaceable>pat</replaceable>.
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:
789 clunky env (lookup env -> Just val1) (lookup env -> Just val2) = val1 + val2
790 ...other equations for clunky...
795 More precisely, the scoping rules are:
799 In a single pattern, variables bound by patterns to the left of a view
800 pattern expression are in scope. For example:
802 example :: Maybe ((String -> Integer,Integer), String) -> Bool
803 example Just ((f,_), f -> 4) = True
806 Additionally, in function definitions, variables bound by matching earlier curried
807 arguments may be used in view pattern expressions in later arguments:
809 example :: (String -> Integer) -> String -> Bool
810 example f (f -> 4) = True
812 That is, the scoping is the same as it would be if the curried arguments
813 were collected into a tuple.
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:
830 restriction in the future; the only cost is that type checking patterns
831 would get a little more complicated.)
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>.
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:
852 case v of { (e -> p) -> e1 ; _ -> e2 }
854 case (e v) of { p -> e1 ; _ -> e2 }
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>.
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
878 f ((view -> A, p1), p2) = e1
879 f ((view -> B, p3), p4) = e2
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.
899 <!-- ===================== n+k patterns =================== -->
901 <sect2 id="n-k-patterns">
902 <title>n+k patterns</title>
903 <indexterm><primary><option>-XNoNPlusKPatterns</option></primary></indexterm>
906 <literal>n+k</literal> pattern support is enabled by default. To disable
907 it, you can use the <option>-XNoNPlusKPatterns</option> flag.
912 <!-- ===================== Recursive do-notation =================== -->
914 <sect2 id="recursive-do-notation">
915 <title>The recursive do-notation
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.
926 Here is a simple (albeit contrived) example:
928 {-# LANGUAGE DoRec #-}
929 justOnes = do { rec { xs <- Just (1:xs) }
930 ; return (map negate xs) }
932 As you can guess <literal>justOnes</literal> will evaluate to <literal>Just [-1,-1,-1,...</literal>.
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.
945 <title>Details of recursive do-notation</title>
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.
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.
957 do { a <- getChar do { a <- getChar
958 ; let { r1 = f a r2 ; rec { r1 <- f a r2
959 ; r2 = g r1 } ; r2 <- g r1 }
960 ; return (r1 ++ r2) } ; return (r1 ++ r2) }
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.)
969 The static and dynamic semantics of <literal>rec</literal> can be described as follows:
973 similar to let-bindings, the <literal>rec</literal> is broken into
974 minimal recursive groups, a process known as <emphasis>segmentation</emphasis>.
977 rec { a <- getChar ===> a <- getChar
978 ; b <- f a c rec { b <- f a c
979 ; c <- f b a ; c <- f b a }
980 ; putChar c } putChar c
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).
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:
991 rec { b <- f a c ===> (b,c) <- mfix (\~(b,c) -> do { b <- f a c
992 ; c <- f b a } ; c <- f b a
995 In general, the statment <literal>rec <replaceable>ss</replaceable></literal>
996 is desugared to the statement
998 <replaceable>vs</replaceable> <- mfix (\~<replaceable>vs</replaceable> -> do { <replaceable>ss</replaceable>; return <replaceable>vs</replaceable> })
1000 where <replaceable>vs</replaceable> is a tuple of the variables bound by <replaceable>ss</replaceable>.
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.
1008 The <literal>mfix</literal> function is defined in the <literal>MonadFix</literal>
1009 class, in <literal>Control.Monad.Fix</literal>, thus:
1011 class Monad m => MonadFix m where
1012 mfix :: (a -> m a) -> m a
1019 Here are some other important points in using the recursive-do notation:
1022 It is enabled with the flag <literal>-XDoRec</literal>, which is in turn implied by
1023 <literal>-fglasgow-exts</literal>.
1027 If recursive bindings are required for a monad,
1028 then that monad must be declared an instance of the <literal>MonadFix</literal> class.
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).
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).
1044 It supports rebindable syntax (see <xref linkend="rebindable-syntax"/>).
1050 <sect3 id="mdo-notation"> <title> Mdo-notation (deprecated) </title>
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>.
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.
1069 <!-- ===================== PARALLEL LIST COMPREHENSIONS =================== -->
1071 <sect2 id="parallel-list-comprehensions">
1072 <title>Parallel List Comprehensions</title>
1073 <indexterm><primary>list comprehensions</primary><secondary>parallel</secondary>
1075 <indexterm><primary>parallel list comprehensions</primary>
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>
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>
1088 [ (x, y) | x <- xs | y <- ys ]
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>
1095 <para>We can define parallel list comprehensions by translation to
1096 regular comprehensions. Here's the basic idea:</para>
1098 <para>Given a parallel comprehension of the form: </para>
1101 [ e | p1 <- e11, p2 <- e12, ...
1102 | q1 <- e21, q2 <- e22, ...
1107 <para>This will be translated to: </para>
1110 [ e | ((p1,p2), (q1,q2), ...) <- zipN [(p1,p2) | p1 <- e11, p2 <- e12, ...]
1111 [(q1,q2) | q1 <- e21, q2 <- e22, ...]
1116 <para>where `zipN' is the appropriate zip for the given number of
1121 <!-- ===================== TRANSFORM LIST COMPREHENSIONS =================== -->
1123 <sect2 id="generalised-list-comprehensions">
1124 <title>Generalised (SQL-Like) List Comprehensions</title>
1125 <indexterm><primary>list comprehensions</primary><secondary>generalised</secondary>
1127 <indexterm><primary>extended list comprehensions</primary>
1129 <indexterm><primary>group</primary></indexterm>
1130 <indexterm><primary>sql</primary></indexterm>
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:
1142 employees = [ ("Simon", "MS", 80)
1143 , ("Erik", "MS", 100)
1144 , ("Phil", "Ed", 40)
1145 , ("Gordon", "Ed", 45)
1146 , ("Paul", "Yale", 60)]
1148 output = [ (the dept, sum salary)
1149 | (name, dept, salary) <- employees
1150 , then group by dept
1151 , then sortWith by (sum salary)
1154 In this example, the list <literal>output</literal> would take on
1158 [("Yale", 60), ("Ed", 85), ("MS", 180)]
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>
1165 <para>There are five new forms of comprehension qualifier,
1166 all introduced by the (existing) keyword <literal>then</literal>:
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>.
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 "project out" some information
1191 from the elements of the list it is transforming.</para>
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>
1203 then group by e using f
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>
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)
1221 output = [ (the x, y)
1222 | x <- ([1..3] ++ [1..2])
1224 , then group by x using groupRuns ]
1227 <para>This results in the variable <literal>output</literal> taking on the value below:</para>
1230 [(1, [4, 5, 6]), (2, [4, 5, 6]), (3, [4, 5, 6]), (1, [4, 5, 6]), (2, [4, 5, 6])]
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>
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>
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>
1268 , then group using inits]
1271 <para>This will yield a list containing every prefix of the word "hello" written out 5 times:</para>
1274 ["","h","he","hel","hell","hello","helloh","hellohe","hellohel","hellohell","hellohello","hellohelloh",...]
1282 <!-- ===================== REBINDABLE SYNTAX =================== -->
1284 <sect2 id="rebindable-syntax">
1285 <title>Rebindable syntax and the implicit Prelude import</title>
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>
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
1309 <para>An integer literal <literal>368</literal> means
1310 "<literal>fromInteger (368::Integer)</literal>", rather than
1311 "<literal>Prelude.fromInteger (368::Integer)</literal>".
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>.
1319 <listitem><para>The equality test in an overloaded numeric pattern
1320 uses whatever <literal>(==)</literal> is in scope.
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.
1329 <para>Negation (e.g. "<literal>- (f x)</literal>")
1330 means "<literal>negate (f x)</literal>", both in numeric
1331 patterns, and expressions.
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>
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
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:
1360 fromInteger :: Integer -> Integer
1361 fromInteger :: forall a. Foo a => Integer -> a
1362 fromInteger :: Num a => a -> Integer
1363 fromInteger :: Integer -> Bool -> Bool
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>
1374 <sect2 id="postfix-operators">
1375 <title>Postfix operators</title>
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
1384 is equivalent (from the point of view of both type checking and execution) to the expression
1388 (for any expression <literal>e</literal> and operator <literal>(!)</literal>.
1389 The strict Haskell 98 interpretation is that the section is equivalent to
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
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>
1402 <sect2 id="tuple-sections">
1403 <title>Tuple sections</title>
1406 The <option>-XTupleSections</option> flag enables Python-style partially applied
1407 tuple constructors. For example, the following program
1411 is considered to be an alternative notation for the more unwieldy alternative
1415 You can omit any combination of arguments to the tuple, as in the following
1417 (, "I", , , "Love", , 1337)
1421 \a b c d -> (a, "I", b, c, "Love", d, 1337)
1426 If you have <link linkend="unboxed-tuples">unboxed tuples</link> enabled, tuple sections
1427 will also be available for them, like so
1431 Because there is no unboxed unit tuple, the following expression
1435 continues to stand for the unboxed singleton tuple data constructor.
1440 <sect2 id="disambiguate-fields">
1441 <title>Record field disambiguation</title>
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:
1448 data S = MkS { x :: Int, y :: Bool }
1453 data T = MkT { x :: Int }
1455 ok1 (MkS { x = n }) = n+1 -- Unambiguous
1456 ok2 n = MkT { x = n+1 } -- Unambiguous
1458 bad1 k = k { x = 3 } -- Ambiguous
1459 bad2 k = x k -- Ambiguous
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.
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.
1484 Field disambiguation can be combined with punning (see <xref linkend="record-puns"/>). For exampe:
1489 ok3 (MkS { x }) = x+1 -- Uses both disambiguation and punning
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:
1499 import qualified M -- Note qualified
1501 ok4 (M.MkS { x = n }) = n+1 -- Unambiguous
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.)
1513 <!-- ===================== Record puns =================== -->
1515 <sect2 id="record-puns">
1520 Record puns are enabled by the flag <literal>-XNamedFieldPuns</literal>.
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:
1528 data C = C {a :: Int}
1534 Record punning permits the variable name to be elided, so one can simply
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>.
1550 Record punning can also be used in an expression, writing, for example,
1556 let a = 1 in C {a = a}
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.
1564 Puns and other patterns can be mixed in the same record:
1566 data C = C {a :: Int, b :: Int}
1567 f (C {a, b = 4}) = a
1572 Puns can be used wherever record patterns occur (e.g. in
1573 <literal>let</literal> bindings or at the top-level).
1577 A pun on a qualified field name is expanded by stripping off the module qualifier.
1584 f (M.C {M.a = a}) = a
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.)
1595 <!-- ===================== Record wildcards =================== -->
1597 <sect2 id="record-wildcards">
1598 <title>Record wildcards
1602 Record wildcards are enabled by the flag <literal>-XRecordWildCards</literal>.
1603 This flag implies <literal>-XDisambiguateRecordFields</literal>.
1607 For records with many fields, it can be tiresome to write out each field
1608 individually in a record pattern, as in
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
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
1621 f (C {a = 1, ..}) = b + c + d
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
1637 defines <literal>b</literal>, <literal>c</literal>, and
1638 <literal>d</literal>.
1642 Record wildcards can also be used in expressions, writing, for example,
1644 let {a = 1; b = 2; c = 3; d = 4} in C {..}
1648 let {a = 1; b = 2; c = 3; d = 4} in C {a=a, b=b, c=c, d=d}
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.
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
1662 data R = R { a,b,c :: Int }
1664 import qualified M( R(a,b) )
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.
1675 <!-- ===================== Local fixity declarations =================== -->
1677 <sect2 id="local-fixity-declarations">
1678 <title>Local Fixity Declarations
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.
1689 <para>In GHC, a fixity declaration may accompany a local binding:
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.
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
1710 let infixr 9 $ in ...
1713 Because local fixity declarations are technically Haskell 98, no flag is
1714 necessary to enable them.
1718 <sect2 id="package-imports">
1719 <title>Package-qualified imports</title>
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>
1726 import "network" Network.Socket
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>
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>
1742 <sect2 id="syntax-stolen">
1743 <title>Summary of stolen syntax</title>
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.
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>
1759 <para>There are two classes of special
1764 <para>New reserved words and symbols: character sequences
1765 which are no longer available for use as identifiers in the
1769 <para>Other special syntax: sequences of characters that have
1770 a different meaning when this particular option is turned
1775 The following syntax is stolen:
1780 <literal>forall</literal>
1781 <indexterm><primary><literal>forall</literal></primary></indexterm>
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>
1796 <literal>mdo</literal>
1797 <indexterm><primary><literal>mdo</literal></primary></indexterm>
1800 Stolen by: <option>-XRecursiveDo</option>,
1806 <literal>foreign</literal>
1807 <indexterm><primary><literal>foreign</literal></primary></indexterm>
1810 Stolen by: <option>-XForeignFunctionInterface</option>,
1816 <literal>rec</literal>,
1817 <literal>proc</literal>, <literal>-<</literal>,
1818 <literal>>-</literal>, <literal>-<<</literal>,
1819 <literal>>>-</literal>, and <literal>(|</literal>,
1820 <literal>|)</literal> brackets
1821 <indexterm><primary><literal>proc</literal></primary></indexterm>
1824 Stolen by: <option>-XArrows</option>,
1830 <literal>?<replaceable>varid</replaceable></literal>,
1831 <literal>%<replaceable>varid</replaceable></literal>
1832 <indexterm><primary>implicit parameters</primary></indexterm>
1835 Stolen by: <option>-XImplicitParams</option>,
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>
1849 Stolen by: <option>-XTemplateHaskell</option>,
1855 <literal>[:<replaceable>varid</replaceable>|</literal>
1856 <indexterm><primary>quasi-quotation</primary></indexterm>
1859 Stolen by: <option>-XQuasiQuotes</option>,
1865 <replaceable>varid</replaceable>{<literal>#</literal>},
1866 <replaceable>char</replaceable><literal>#</literal>,
1867 <replaceable>string</replaceable><literal>#</literal>,
1868 <replaceable>integer</replaceable><literal>#</literal>,
1869 <replaceable>float</replaceable><literal>#</literal>,
1870 <replaceable>float</replaceable><literal>##</literal>,
1871 <literal>(#</literal>, <literal>#)</literal>,
1874 Stolen by: <option>-XMagicHash</option>,
1883 <!-- TYPE SYSTEM EXTENSIONS -->
1884 <sect1 id="data-type-extensions">
1885 <title>Extensions to data types and type synonyms</title>
1887 <sect2 id="nullary-types">
1888 <title>Data types with no constructors</title>
1890 <para>With the <option>-fglasgow-exts</option> flag, GHC lets you declare
1891 a data type with no constructors. For example:</para>
1895 data T a -- T :: * -> *
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>
1903 <para>Such data types have only one value, namely bottom.
1904 Nevertheless, they can be useful when defining "phantom types".</para>
1907 <sect2 id="infix-tycons">
1908 <title>Infix type constructors, classes, and type variables</title>
1911 GHC allows type constructors, classes, and type variables to be operators, and
1912 to be written infix, very much like expressions. More specifically:
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.
1919 Data type and type-synonym declarations can be written infix, parenthesised
1920 if you want further arguments. E.g.
1922 data a :*: b = Foo a b
1923 type a :+: b = Either a b
1924 class a :=: b where ...
1926 data (a :**: b) x = Baz a b x
1927 type (a :++: b) y = Either (a,b) y
1931 Types, and class constraints, can be written infix. For example
1934 f :: (a :=: b) => a -> b
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:
1943 type T (+) = Int + Int
1947 liftA2 :: Arrow (~>)
1948 => (a -> b -> c) -> (e ~> a) -> (e ~> b) -> (e ~> c)
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>.
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:
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>.
1969 Function arrow is <literal>infixr</literal> with fixity 0. (This might change; I'm not sure what it should be.)
1976 <sect2 id="type-synonyms">
1977 <title>Liberalised type synonyms</title>
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.
1987 <listitem> <para>You can write a <literal>forall</literal> (including overloading)
1988 in a type synonym, thus:
1990 type Discard a = forall b. Show b => a -> b -> (a, String)
1995 g :: Discard Int -> (Int,String) -- A rank-2 type
2002 If you also use <option>-XUnboxedTuples</option>,
2003 you can write an unboxed tuple in a type synonym:
2005 type Pr = (# Int, Int #)
2013 You can apply a type synonym to a forall type:
2015 type Foo a = a -> a -> Bool
2017 f :: Foo (forall b. b->b)
2019 After expanding the synonym, <literal>f</literal> has the legal (in GHC) type:
2021 f :: (forall b. b->b) -> (forall b. b->b) -> Bool
2026 You can apply a type synonym to a partially applied type synonym:
2028 type Generic i o = forall x. i x -> o x
2031 foo :: Generic Id []
2033 After expanding the synonym, <literal>foo</literal> has the legal (in GHC) type:
2035 foo :: forall x. x -> [x]
2043 GHC currently does kind checking before expanding synonyms (though even that
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:
2051 Type constructor applied to a type involving for-alls.
2054 Unboxed tuple on left of an arrow.
2057 Partially-applied type synonym.
2061 this will be rejected:
2063 type Pr = (# Int, Int #)
2068 because GHC does not allow unboxed tuples on the left of a function arrow.
2073 <sect2 id="existential-quantification">
2074 <title>Existentially quantified data constructors
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:
2092 data Foo = forall a. MkFoo a (a -> Bool)
2099 The data type <literal>Foo</literal> has two constructors with types:
2105 MkFoo :: forall a. a -> (a -> Bool) -> Foo
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:
2120 [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
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.
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>?
2140 f (MkFoo val fn) = ???
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:
2155 f (MkFoo val fn) = fn val
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.
2167 <sect3 id="existential">
2168 <title>Why existential?
2172 What has this to do with <emphasis>existential</emphasis> quantification?
2173 Simply that <function>MkFoo</function> has the (nearly) isomorphic type
2179 MkFoo :: (exists a . (a, a -> Bool)) -> Foo
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.
2192 <sect3 id="existential-with-context">
2193 <title>Existentials and type classes</title>
2196 An easy extension is to allow
2197 arbitrary contexts before the constructor. For example:
2203 data Baz = forall a. Eq a => Baz1 a a
2204 | forall b. Show b => Baz2 b (b -> b)
2210 The two constructors have the types you'd expect:
2216 Baz1 :: forall a. Eq a => a -> a -> Baz
2217 Baz2 :: forall b. Show b => b -> (b -> b) -> Baz
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:
2233 f (Baz1 p q) | p == q = "Yes"
2235 f (Baz2 v fn) = show (fn v)
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.
2249 <sect3 id="existential-records">
2250 <title>Record Constructors</title>
2253 GHC allows existentials to be used with records syntax as well. For example:
2256 data Counter a = forall self. NewCounter
2258 , _inc :: self -> self
2259 , _display :: self -> IO ()
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.)
2274 To make use of these hidden fields, we need to create some helper functions:
2277 inc :: Counter a -> Counter a
2278 inc (NewCounter x i d t) = NewCounter
2279 { _this = i x, _inc = i, _display = d, tag = t }
2281 display :: Counter a -> IO ()
2282 display NewCounter{ _this = x, _display = d } = d x
2285 Now we can define counters with different underlying implementations:
2288 counterA :: Counter String
2289 counterA = NewCounter
2290 { _this = 0, _inc = (1+), _display = print, tag = "A" }
2292 counterB :: Counter String
2293 counterB = NewCounter
2294 { _this = "", _inc = ('#':), _display = putStrLn, tag = "B" }
2297 display (inc counterA) -- prints "1"
2298 display (inc (inc counterB)) -- prints "##"
2301 Record update syntax is supported for existentials (and GADTs):
2303 setTag :: Counter a -> a -> Counter a
2304 setTag obj t = obj{ tag = t }
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:
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)
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)
2329 <title>Restrictions</title>
2332 There are several restrictions on the ways in which existentially-quantified
2333 constructors can be use.
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:
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:
2359 f1 :: Foo -> a -- Weird!
2363 What is this "<literal>a</literal>" in the result type? Clearly we don't mean
2368 f1 :: forall a. Foo -> a -- Wrong!
2372 The original program is just plain wrong. Here's another sort of error
2376 f2 (Baz1 a b) (Baz1 p q) = a==q
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.
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:
2396 f3 x = a==b where { Baz1 a b = x }
2399 Instead, use a <literal>case</literal> expression:
2402 f3 x = case x of Baz1 a b -> a==b
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.
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
2422 You can't use existential quantification for <literal>newtype</literal>
2423 declarations. So this is illegal:
2427 newtype T = forall a. Ord a => MkT a
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.
2451 You can't use <literal>deriving</literal> to define instances of a
2452 data type with existentially quantified data constructors.
2454 Reason: in most cases it would not make sense. For example:;
2457 data T = forall a. MkT [a] deriving( Eq )
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:
2465 (MkT a) == (MkT b) = ???
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!
2482 <!-- ====================== Generalised algebraic data types ======================= -->
2484 <sect2 id="gadt-style">
2485 <title>Declaring data types with explicit constructor signatures</title>
2487 <para>GHC allows you to declare an algebraic data type by
2488 giving the type signatures of constructors explicitly. For example:
2492 Just :: a -> Maybe a
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:
2500 data Foo = forall a. MkFoo a (a -> Bool)
2501 data Foo' where { MKFoo :: a -> (a->Bool) -> Foo' }
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:
2512 MkSet :: Eq a => [a] -> Set a
2514 makeSet :: Eq a => [a] -> Set a
2515 makeSet xs = MkSet (nub xs)
2517 insert :: a -> Set a -> Set a
2518 insert a (MkSet as) | a `elem` as = MkSet as
2519 | otherwise = MkSet (a:as)
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.
2533 For example, one possible application is to reify dictionaries:
2535 data NumInst a where
2536 MkNumInst :: Num a => NumInst a
2538 intInst :: NumInst Int
2541 plus :: NumInst a -> a -> a -> a
2542 plus MkNumInst p q = p + q
2544 Here, a value of type <literal>NumInst a</literal> is equivalent
2545 to an explicit <literal>(Num a)</literal> dictionary.
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
2553 = Num a => MkNumInst (NumInst a)
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:
2562 = forall b. (Num a, Eq b) => MkT1 a b
2564 MkT2 :: (Num a, Eq b) => a -> b -> T2 a
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
2571 data Eq a => Set' a = MkSet' [a]
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.
2581 The rest of this section gives further details about GADT-style data
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"/>).
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>:
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:
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
2616 A constructor signature may mention type class constraints, which can differ for
2617 different constructors. For example, this is fine:
2620 T1 :: Eq b => b -> b -> T b
2621 T2 :: (Show c, Ix c) => c -> [c] -> T c
2623 When patten matching, these constraints are made available to discharge constraints
2624 in the body of the match. For example:
2627 f (T1 x y) | x==y = "yes"
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>.
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:
2641 data Set :: * -> * where ...
2643 or even a mixture of the two:
2645 data Bar a :: (* -> *) -> * where ...
2647 The type variables (if given) may be explicitly kinded, so we could also write the header for <literal>Foo</literal>
2650 data Bar a (b :: * -> *) where ...
2656 You can use strictness annotations, in the obvious places
2657 in the constructor type:
2660 Lit :: !Int -> Term Int
2661 If :: Term Bool -> !(Term a) -> !(Term a) -> Term a
2662 Pair :: Term a -> Term b -> Term (a,b)
2667 You can use a <literal>deriving</literal> clause on a GADT-style data type
2668 declaration. For example, these two declarations are equivalent
2670 data Maybe1 a where {
2671 Nothing1 :: Maybe1 a ;
2672 Just1 :: a -> Maybe1 a
2673 } deriving( Eq, Ord )
2675 data Maybe2 a = Nothing2 | Just2 a
2681 The type signature may have quantified type variables that do not appear
2685 MkFoo :: a -> (a->Bool) -> Foo
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"/>.
2695 The type may contain a class context too, of course:
2698 MkShowable :: Show a => a -> Showable
2703 You can use record syntax on a GADT-style data type declaration:
2707 Adult :: { name :: String, children :: [Person] } -> Person
2708 Child :: Show a => { name :: !String, funny :: a } -> Person
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.)
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.
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
2730 Here is the example of that section, in GADT-style syntax:
2732 data Counter a where
2733 NewCounter { _this :: self
2734 , _inc :: self -> self
2735 , _display :: self -> IO ()
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.
2743 </itemizedlist></para>
2747 <title>Generalised Algebraic Data Types (GADTs)</title>
2749 <para>Generalised Algebraic Data Types generalise ordinary algebraic data types
2750 by allowing constructors to have richer return types. Here is an example:
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)
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>:
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)
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
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
2781 url="http://research.microsoft.com/%7Esimonpj/papers/gadt/">Simple
2782 unification-based type inference for GADTs</ulink>,
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:
2790 eval :: Term a -> a -> a
2791 eval (Lit i) j = i+j
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.
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>,
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.
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>.
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>
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>.
2827 You cannot use a <literal>deriving</literal> clause for a GADT; only for
2828 an ordinary data type.
2832 As mentioned in <xref linkend="gadt-style"/>, record syntax is supported.
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
2843 If { cnd :: Term Bool
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:
2857 num :: Term Int -> Term Int
2858 arg :: Term Bool -> Term Int
2863 When pattern-matching against data constructors drawn from a GADT,
2864 for example in a <literal>case</literal> expression, the following rules apply:
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>
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.
2885 <!-- ====================== End of Generalised algebraic data types ======================= -->
2887 <sect1 id="deriving">
2888 <title>Extensions to the "deriving" mechanism</title>
2890 <sect2 id="deriving-inferred">
2891 <title>Inferred context for deriving clauses</title>
2894 The Haskell Report is vague about exactly when a <literal>deriving</literal> clause is
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 )
2901 The natural generated <literal>Eq</literal> code would result in these instance declarations:
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 ...
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.
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.
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>.
2921 <sect2 id="stand-alone-deriving">
2922 <title>Stand-alone deriving declarations</title>
2925 GHC now allows stand-alone <literal>deriving</literal> declarations, enabled by <literal>-XStandaloneDeriving</literal>:
2927 data Foo a = Bar a | Baz String
2929 deriving instance Eq a => Eq (Foo a)
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:
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.)
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"/>.
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
2955 data Foo a = Bar a | Baz String
2957 deriving instance Eq a => Eq (Foo [a])
2958 deriving instance Eq a => Eq (Foo (Maybe a))
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>.
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:
2977 deriving instance Show (T a)
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.
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"/>).
2991 newtype Foo a = MkFoo (State Int a)
2993 deriving instance MonadState Int Foo
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.
2998 </itemizedlist></para>
3003 <sect2 id="deriving-typeable">
3004 <title>Deriving clause for extra classes (<literal>Typeable</literal>, <literal>Data</literal>, etc)</title>
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>.
3014 GHC extends this list with several more classes that may be automatically derived:
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.
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
3024 <ulink url="http://research.microsoft.com/%7Esimonpj/papers/hmap/gmap2.ps">
3025 Scrap More Boilerplate: Reflection, Zips, and Generalised Casts
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.
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>.
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>.
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>.
3051 In each case the appropriate class must be in scope before it
3052 can be mentioned in the <literal>deriving</literal> clause.
3056 <sect2 id="newtype-deriving">
3057 <title>Generalised derived instances for newtypes</title>
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
3068 newtype Dollars = Dollars Int
3071 and you want to use arithmetic on <literal>Dollars</literal>, you have to
3072 explicitly define an instance of <literal>Num</literal>:
3075 instance Num Dollars where
3076 Dollars a + Dollars b = Dollars (a+b)
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!
3087 <sect3> <title> Generalising the deriving clause </title>
3089 GHC now permits such instances to be derived instead,
3090 using the flag <option>-XGeneralizedNewtypeDeriving</option>,
3093 newtype Dollars = Dollars Int deriving (Eq,Show,Num)
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
3101 instance Num Int => Num Dollars
3104 which just adds or removes the <literal>newtype</literal> constructor according to the type.
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
3113 instance Monad m => Monad (State s m)
3114 instance Monad m => Monad (Failure m)
3116 In Haskell 98, we can define a parsing monad by
3118 type Parser tok m a = State [tok] (Failure m) a
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
3126 newtype Parser tok m a = Parser (State [tok] (Failure m) a)
3129 In this case the derived instance declaration is of the form
3131 instance Monad (State [tok] (Failure m)) => Monad (Parser tok m)
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
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
3148 class StateMonad s m | m -> s where ...
3149 instance Monad m => StateMonad s (State s m) where ...
3151 then we can derive an instance of <literal>StateMonad</literal> for <literal>Parser</literal>s by
3153 newtype Parser tok m a = Parser (State [tok] (Failure m) a)
3154 deriving (Monad, StateMonad [tok])
3157 The derived instance is obtained by completing the application of the
3158 class to the new type:
3161 instance StateMonad [tok] (State [tok] (Failure m)) =>
3162 StateMonad [tok] (Parser tok m)
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.
3175 <sect3> <title> A more precise specification </title>
3177 Derived instance declarations are constructed as follows. Consider the
3178 declaration (after expansion of any type synonyms)
3181 newtype T v1...vn = T' (t vk+1...vn) deriving (c1...cm)
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.
3192 The <literal>k</literal> is chosen so that <literal>ci (T v1...vk)</literal> is well-kinded.
3195 The type <literal>t</literal> is an arbitrary type.
3198 The type variables <literal>vk+1...vn</literal> do not occur in <literal>t</literal>,
3199 nor in the <literal>ci</literal>, and
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.
3209 Then, for each <literal>ci</literal>, the derived instance
3212 instance ci t => ci (T v1...vk)
3214 As an example which does <emphasis>not</emphasis> work, consider
3216 newtype NonMonad m s = NonMonad (State s m s) deriving Monad
3218 Here we cannot derive the instance
3220 instance Monad (State s m) => Monad (NonMonad m)
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.
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
3236 class StateMonad m s | m -> s where ...
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.
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.)
3257 <!-- TYPE SYSTEM EXTENSIONS -->
3258 <sect1 id="type-class-extensions">
3259 <title>Class and instances declarations</title>
3261 <sect2 id="multi-param-type-classes">
3262 <title>Class declarations</title>
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).
3272 All the extensions are enabled by the <option>-fglasgow-exts</option> flag.
3276 <title>Multi-parameter type classes</title>
3278 Multi-parameter type classes are permitted, with flag <option>-XMultiParamTypeClasses</option>.
3283 class Collection c a where
3284 union :: c a -> c a -> c a
3291 <sect3 id="superclass-rules">
3292 <title>The superclasses of a class declaration</title>
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:
3305 class Functor (m k) => FiniteMap m k where
3308 class (Monad m, Monad (t m)) => Transform t m where
3309 lift :: m a -> (t m) a
3315 As in Haskell 98, The class hierarchy must be acyclic. However, the definition
3316 of "acyclic" involves only the superclass relationships. For example,
3322 op :: D b => a -> b -> b
3325 class C a => D a where { ... }
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>.)
3338 <sect3 id="class-method-types">
3339 <title>Class method types</title>
3342 Haskell 98 prohibits class method types to mention constraints on the
3343 class type variable, thus:
3346 fromList :: [a] -> s a
3347 elem :: Eq a => a -> s a -> Bool
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>).
3359 <sect2 id="functional-dependencies">
3360 <title>Functional dependencies
3363 <para> Functional dependencies are implemented as described by Mark Jones
3364 in “<ulink url="http://citeseer.ist.psu.edu/jones00type.html">Type Classes with Functional Dependencies</ulink>”, Mark P. Jones,
3365 In Proceedings of the 9th European Symposium on Programming,
3366 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782,
3370 Functional dependencies are introduced by a vertical bar in the syntax of a
3371 class declaration; e.g.
3373 class (Monad m) => MonadState s m | m -> s where ...
3375 class Foo a b c | a b -> c where ...
3377 There should be more documentation, but there isn't (yet). Yell if you need it.
3380 <sect3><title>Rules for functional dependencies </title>
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.
3388 class Coll s a where
3390 insert :: s -> a -> s
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
3397 class Coll s a | s -> a where
3399 insert :: s -> a -> s
3402 Alternatively <literal>Coll</literal> might be rewritten
3405 class Coll s a where
3407 insert :: s a -> a -> s a
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
3421 class CollE s => Coll s a where
3422 insert :: s -> a -> s
3429 <title>Background on functional dependencies</title>
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.
3436 Consider the following class, intended as part of a
3437 library for collection types:
3439 class Collects e ce where
3441 insert :: e -> ce -> ce
3442 member :: e -> ce -> Bool
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:
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 ...
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:
3462 empty :: Collects e ce => ce
3464 By "ambiguous" we mean that there is a type variable e that appears on the left
3465 of the <literal>=></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
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:
3476 f x y = insert x . insert y
3479 for which GHC infers the following types:
3481 f :: (Collects a c, Collects b c) => a -> b -> c -> c
3482 g :: (Collects Bool c, Collects Char c) => c -> c
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.
3494 <sect4><title>An attempt to use constructor classes</title>
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:
3500 class Collects e c where
3502 insert :: e -> c e -> c e
3503 member :: e -> c e -> Bool
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.
3512 The function f from the previous section has a more accurate type:
3514 f :: (Collects e c) => e -> e -> c e -> c e
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
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.
3530 <sect4><title>Adding functional dependencies</title>
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.).
3544 To start with an abstract example, consider a declaration such as:
3546 class C a b where ...
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:
3553 class D a b | a -> b where ...
3554 class E a b | a -> b, b -> a where ...
3556 The notation <literal>a -> 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.
3565 More generally, dependencies take the form <literal>x1 ... xn -> y1 ... ym</literal>,
3566 where x1, ..., xn, and y1, ..., yn are type variables with n>0 and
3567 m>=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 -> 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 -> a </literal>,
3575 <literal>a -> a a </literal>,
3576 <literal>a -> </literal>, etc. There can also be
3577 some redundancy if multiple dependencies are given, as in
3578 <literal>a->b</literal>,
3579 <literal>b->c </literal>, <literal>a->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
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:
3595 instance D Bool Int where ...
3596 instance D Bool Char where ...
3598 Note also that the following declaration is not allowed, even by itself:
3600 instance D [a] b where ...
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:
3607 instance D t s where ...
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.
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:
3620 class Collects e ce | ce -> e where
3622 insert :: e -> ce -> ce
3623 member :: e -> ce -> Bool
3625 The dependency <literal>ce -> 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.
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.
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
3649 f x y = insert x y = insert x . insert y
3651 for which we originally obtained a type:
3653 f :: (Collects a c, Collects b c) => a -> b -> c -> c
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:
3660 f :: (Collects a c) => a -> a -> c -> c
3662 In a similar way, the earlier definition of g will now be flagged as a type error.
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.
3674 <sect2 id="instance-decls">
3675 <title>Instance declarations</title>
3677 <para>An instance declaration has the form
3679 instance ( <replaceable>assertion</replaceable><subscript>1</subscript>, ..., <replaceable>assertion</replaceable><subscript>n</subscript>) => <replaceable>class</replaceable> <replaceable>type</replaceable><subscript>1</subscript> ... <replaceable>type</replaceable><subscript>m</subscript> where ...
3681 The part before the "<literal>=></literal>" is the
3682 <emphasis>context</emphasis>, while the part after the
3683 "<literal>=></literal>" is the <emphasis>head</emphasis> of the instance declaration.
3686 <sect3 id="flexible-instance-head">
3687 <title>Relaxed rules for the instance head</title>
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.
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
3702 instance C (Maybe Int) where ...
3704 See also the <link linkend="instance-overlap">rules on overlap</link>.
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:
3713 type Point = (Int,Int)
3714 instance C Point where ...
3715 instance C [Point] where ...
3719 is legal. However, if you added
3723 instance C (Int,Int) where ...
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:
3733 instance Monad P where ...
3741 <sect3 id="instance-rules">
3742 <title>Relaxed rules for instance contexts</title>
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.
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
3757 The Paterson Conditions: for each assertion in the context
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>
3765 <listitem><para>The Coverage Condition. For each functional dependency,
3766 <replaceable>tvs</replaceable><subscript>left</subscript> <literal>-></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.
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>.
3786 For example, these are OK:
3788 instance C Int [a] -- Multiple parameters
3789 instance Eq (S [a]) -- Structured type in head
3791 -- Repeated type variable in head
3792 instance C4 a a => C4 [a] [a]
3793 instance Stateful (ST s) (MutVar s)
3795 -- Head can consist of type variables only
3797 instance (Eq a, Show b) => C2 a b
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
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 ...
3814 The same restrictions apply to instances generated by
3815 <literal>deriving</literal> clauses. Thus the following is accepted:
3817 data MinHeap h a = H a (h a)
3820 because the derived instance
3822 instance (Show a, Show (h a)) => Show (MinHeap h a)
3824 conforms to the above rules.
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:
3839 <sect3 id="undecidable-instances">
3840 <title>Undecidable instances</title>
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":
3847 class (C1 a, C2 a, C3 a) => C a where { }
3849 instance (C1 a, C2 a, C3 a) => C a where { }
3851 This allows you to write shorter signatures:
3857 f :: (C1 a, C2 a, C3 a) => ...
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:
3864 class HasConverter a b | a -> b where
3867 data Foo a = MkFoo a
3869 instance (HasConverter a b,Show b) => Show (Foo a) where
3870 show (MkFoo value) = show (convert value)
3872 This is dangerous territory, however. Here, for example, is a program that would make the
3877 instance F [a] [[a]]
3878 instance (D c, F a c) => D [a] -- 'c' is not mentioned in the head
3880 Similarly, it can be tempting to lift the coverage condition:
3882 class Mul a b c | a b -> c where
3883 (.*.) :: a -> b -> c
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
3889 The third instance declaration does not obey the coverage condition;
3890 and indeed the (somewhat strange) definition:
3892 f = \ b x y -> if b then x .*. [y] else y
3894 makes instance inference go into a loop, because it requires the constraint
3895 <literal>(Mul a [b] b)</literal>.
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>.
3911 <sect3 id="instance-overlap">
3912 <title>Overlapping instances</title>
3914 In general, <emphasis>GHC requires that that it be unambiguous which instance
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>
3926 When GHC tries to resolve, say, the constraint <literal>C Int Bool</literal>,
3927 it tries to match every instance declaration against the
3929 by instantiating the head of the instance declaration. For example, consider
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)
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.
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.
3956 However, GHC is conservative about committing to an overlapping instance. For example:
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.)
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
3979 f :: C Int [b] => [b] -> [b]
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>
3989 Exactly the same situation can arise in instance declarations themselves. Suppose we have
3993 instance Foo [b] where
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:
4002 instance C Int [b] => Foo [b] where
4005 (You need <link linkend="instance-rules"><option>-XFlexibleInstances</option></link> to do this.)
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:
4012 {-# LANGUAGE OverlappingInstances #-}
4015 class MyShow a where
4016 myshow :: a -> String
4018 instance MyShow a => MyShow [a] where
4019 myshow xs = concatMap myshow xs
4021 showHelp :: MyShow a => [a] -> String
4022 showHelp xs = myshow xs
4024 {-# LANGUAGE FlexibleInstances, OverlappingInstances #-}
4030 instance MyShow T where
4031 myshow x = "Used generic instance"
4033 instance MyShow [T] where
4034 myshow xs = "Used more specific instance"
4036 main = do { print (myshow [MkT]); print (showHelp [MkT]) }
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,
4045 "Used more specific instance"
4046 "Used generic instance"
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.)
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:
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.
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.
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.
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.
4090 <para>The <option>-XIncoherentInstances</option> flag implies the
4091 <option>-XOverlappingInstances</option> flag, but not vice versa.
4099 <sect2 id="overloaded-strings">
4100 <title>Overloaded string literals
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>.
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.
4117 The class <literal>IsString</literal> is defined as:
4119 class IsString a where
4120 fromString :: String -> a
4122 The only predefined instance is the obvious one to make strings work as usual:
4124 instance IsString [Char] where
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>.
4132 Haskell's defaulting mechanism is extended to cover string literals, when <option>-XOverloadedStrings</option> is specified.
4136 Each type in a default declaration must be an
4137 instance of <literal>Num</literal> <emphasis>or</emphasis> of <literal>IsString</literal>.
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>.
4153 import GHC.Exts( IsString(..) )
4155 newtype MyString = MyString String deriving (Eq, Show)
4156 instance IsString MyString where
4157 fromString = MyString
4159 greet :: MyString -> MyString
4160 greet "hello" = "world"
4164 print $ greet "hello"
4165 print $ greet "fool"
4169 Note that deriving <literal>Eq</literal> is necessary for the pattern matching
4170 to work since it gets translated into an equality comparison.