2 <indexterm><primary>language, GHC</primary></indexterm>
3 <indexterm><primary>extensions, GHC</primary></indexterm>
4 As with all known Haskell systems, GHC implements some extensions to
5 the language. To use them, you'll need to give a <option>-fglasgow-exts</option>
6 <indexterm><primary>-fglasgow-exts option</primary></indexterm> option.
10 Virtually all of the Glasgow extensions serve to give you access to
11 the underlying facilities with which we implement Haskell. Thus, you
12 can get at the Raw Iron, if you are willing to write some non-standard
13 code at a more primitive level. You need not be “stuck” on
14 performance because of the implementation costs of Haskell's
15 “high-level” features—you can always code “under” them. In an extreme case, you can write all your time-critical code in C, and then just glue it together with Haskell!
19 Executive summary of our extensions:
25 <term>Unboxed types and primitive operations:</Term>
27 <para>You can get right down to the raw machine types and
28 operations; included in this are “primitive
29 arrays” (direct access to Big Wads of Bytes). Please
30 see <XRef LinkEnd="glasgow-unboxed"> and following.</para>
35 <term>Type system extensions:</term>
37 <para> GHC supports a large number of extensions to Haskell's
38 type system. Specifically:</para>
42 <term>Multi-parameter type classes:</term>
44 <para><xref LinkEnd="multi-param-type-classes"></para>
49 <term>Functional dependencies:</term>
51 <para><xref LinkEnd="functional-dependencies"></para>
56 <term>Implicit parameters:</term>
58 <para><xref LinkEnd="implicit-parameters"></para>
63 <term>Local universal quantification:</term>
65 <para><xref LinkEnd="universal-quantification"></para>
70 <term>Extistentially quantification in data types:</term>
72 <para><xref LinkEnd="existential-quantification"></para>
77 <term>Scoped type variables:</term>
79 <para>Scoped type variables enable the programmer to
80 supply type signatures for some nested declarations,
81 where this would not be legal in Haskell 98. Details in
82 <xref LinkEnd="scoped-type-variables">.</para>
90 <term>Pattern guards</term>
92 <para>Instead of being a boolean expression, a guard is a list
93 of qualifiers, exactly as in a list comprehension. See <xref
94 LinkEnd="pattern-guards">.</para>
99 <term>Parallel list comprehensions</term>
101 <para>An extension to the list comprehension syntax to support
102 <literal>zipWith</literal>-like functionality. See <xref
103 linkend="parallel-list-comprehensions">.</para>
108 <term>Foreign calling:</term>
110 <para>Just what it sounds like. We provide
111 <emphasis>lots</emphasis> of rope that you can dangle around
112 your neck. Please see <xref LinkEnd="ffi">.</para>
119 <para>Pragmas are special instructions to the compiler placed
120 in the source file. The pragmas GHC supports are described in
121 <xref LinkEnd="pragmas">.</para>
126 <term>Rewrite rules:</term>
128 <para>The programmer can specify rewrite rules as part of the
129 source program (in a pragma). GHC applies these rewrite rules
130 wherever it can. Details in <xref
131 LinkEnd="rewrite-rules">.</para>
136 <term>Generic classes:</term>
138 <para>Generic class declarations allow you to define a class
139 whose methods say how to work over an arbitrary data type.
140 Then it's really easy to make any new type into an instance of
141 the class. This generalises the rather ad-hoc "deriving"
142 feature of Haskell 98. Details in <xref
143 LinkEnd="generic-classes">.</para>
149 Before you get too carried away working at the lowest level (e.g.,
150 sloshing <literal>MutableByteArray#</literal>s around your
151 program), you may wish to check if there are libraries that provide a
152 “Haskellised veneer” over the features you want. See
153 <xref linkend="book-hslibs">.
156 <sect1 id="options-language">
157 <title>Language options</title>
159 <indexterm><primary>language</primary><secondary>option</secondary>
161 <indexterm><primary>options</primary><secondary>language</secondary>
163 <indexterm><primary>extensions</primary><secondary>options controlling</secondary>
166 <para> These flags control what variation of the language are
167 permitted. Leaving out all of them gives you standard Haskell
173 <term><option>-fglasgow-exts</option>:</term>
174 <indexterm><primary><option>-fglasgow-exts</option></primary></indexterm>
176 <para>This simultaneously enables all of the extensions to
177 Haskell 98 described in <xref
178 linkend="ghc-language-features">, except where otherwise
184 <term><option>-fno-monomorphism-restriction</option>:</term>
185 <indexterm><primary><option>-fno-monomorphism-restriction</option></primary></indexterm>
187 <para> Switch off the Haskell 98 monomorphism restriction.
188 Independent of the <option>-fglasgow-exts</option>
194 <term><option>-fallow-overlapping-instances</option></term>
195 <term><option>-fallow-undecidable-instances</option></term>
196 <term><option>-fcontext-stack</option></term>
197 <indexterm><primary><option>-fallow-overlapping-instances</option></primary></indexterm>
198 <indexterm><primary><option>-fallow-undecidable-instances</option></primary></indexterm>
199 <indexterm><primary><option>-fcontext-stack</option></primary></indexterm>
201 <para> See <xref LinkEnd="instance-decls">. Only relevant
202 if you also use <option>-fglasgow-exts</option>.</para>
207 <term><option>-finline-phase</option></term>
208 <indexterm><primary><option>-finline-phase</option></primary></indexterm>
210 <para>See <xref LinkEnd="rewrite-rules">. Only relevant if
211 you also use <option>-fglasgow-exts</option>.</para>
216 <term><option>-fgenerics</option></term>
217 <indexterm><primary><option>-fgenerics</option></primary></indexterm>
219 <para>See <xref LinkEnd="generic-classes">. Independent of
220 <option>-fglasgow-exts</option>.</para>
225 <term><option>-fno-implicit-prelude</option></term>
227 <para><indexterm><primary>-fno-implicit-prelude
228 option</primary></indexterm> GHC normally imports
229 <filename>Prelude.hi</filename> files for you. If you'd
230 rather it didn't, then give it a
231 <option>-fno-implicit-prelude</option> option. The idea
232 is that you can then import a Prelude of your own. (But
233 don't call it <literal>Prelude</literal>; the Haskell
234 module namespace is flat, and you must not conflict with
235 any Prelude module.)</para>
237 <para>Even though you have not imported the Prelude, all
238 the built-in syntax still refers to the built-in Haskell
239 Prelude types and values, as specified by the Haskell
240 Report. For example, the type <literal>[Int]</literal>
241 still means <literal>Prelude.[] Int</literal>; tuples
242 continue to refer to the standard Prelude tuples; the
243 translation for list comprehensions continues to use
244 <literal>Prelude.map</literal> etc.</para>
246 <para> With one group of exceptions! You may want to
247 define your own numeric class hierarchy. It completely
248 defeats that purpose if the literal "1" means
249 "<literal>Prelude.fromInteger 1</literal>", which is what
250 the Haskell Report specifies. So the
251 <option>-fno-implicit-prelude</option> flag causes the
252 following pieces of built-in syntax to refer to <emphasis>whatever
253 is in scope</emphasis>, not the Prelude versions:</para>
257 <para>Integer and fractional literals mean
258 "<literal>fromInteger 1</literal>" and
259 "<literal>fromRational 3.2</literal>", not the
260 Prelude-qualified versions; both in expressions and in
265 <para>Negation (e.g. "<literal>- (f x)</literal>")
266 means "<literal>negate (f x)</literal>" (not
267 <literal>Prelude.negate</literal>).</para>
271 <para>In an n+k pattern, the standard Prelude
272 <literal>Ord</literal> class is still used for comparison,
273 but the necessary subtraction uses whatever
274 "<literal>(-)</literal>" is in scope (not
275 "<literal>Prelude.(-)</literal>").</para>
279 <para>Note: Negative literals, such as <literal>-3</literal>, are
280 specified by (a careful reading of) the Haskell Report as
281 meaning <literal>Prelude.negate (Prelude.fromInteger 3)</literal>.
282 However, GHC deviates from this slightly, and treats them as meaning
283 <literal>fromInteger (-3)</literal>. One particular effect of this
284 slightly-non-standard reading is that there is no difficulty with
285 the literal <literal>-2147483648</literal> at type <literal>Int</literal>;
286 it means <literal>fromInteger (-2147483648)</literal>. The strict interpretation
287 would be <literal>negate (fromInteger 2147483648)</literal>,
288 and the call to <literal>fromInteger</literal> would overflow
289 (at type <literal>Int</literal>, remember).
298 <!-- UNBOXED TYPES AND PRIMITIVE OPERATIONS -->
301 <sect1 id="glasgow-ST-monad">
302 <title>Primitive state-transformer monad</title>
305 <indexterm><primary>state transformers (Glasgow extensions)</primary></indexterm>
306 <indexterm><primary>ST monad (Glasgow extension)</primary></indexterm>
310 This monad underlies our implementation of arrays, mutable and
311 immutable, and our implementation of I/O, including “C calls”.
315 The <literal>ST</literal> library, which provides access to the
316 <function>ST</function> monad, is described in <xref
322 <sect1 id="glasgow-prim-arrays">
323 <title>Primitive arrays, mutable and otherwise
327 <indexterm><primary>primitive arrays (Glasgow extension)</primary></indexterm>
328 <indexterm><primary>arrays, primitive (Glasgow extension)</primary></indexterm>
332 GHC knows about quite a few flavours of Large Swathes of Bytes.
336 First, GHC distinguishes between primitive arrays of (boxed) Haskell
337 objects (type <literal>Array# obj</literal>) and primitive arrays of bytes (type
338 <literal>ByteArray#</literal>).
342 Second, it distinguishes between…
346 <term>Immutable:</term>
349 Arrays that do not change (as with “standard” Haskell arrays); you
350 can only read from them. Obviously, they do not need the care and
351 attention of the state-transformer monad.
356 <term>Mutable:</term>
359 Arrays that may be changed or “mutated.” All the operations on them
360 live within the state-transformer monad and the updates happen
361 <emphasis>in-place</emphasis>.
366 <term>“Static” (in C land):</term>
369 A C routine may pass an <literal>Addr#</literal> pointer back into Haskell land. There
370 are then primitive operations with which you may merrily grab values
371 over in C land, by indexing off the “static” pointer.
376 <term>“Stable” pointers:</term>
379 If, for some reason, you wish to hand a Haskell pointer (i.e.,
380 <emphasis>not</emphasis> an unboxed value) to a C routine, you first make the
381 pointer “stable,” so that the garbage collector won't forget that it
382 exists. That is, GHC provides a safe way to pass Haskell pointers to
387 Please see <xref LinkEnd="sec-stable-pointers"> for more details.
392 <term>“Foreign objects”:</term>
395 A “foreign object” is a safe way to pass an external object (a
396 C-allocated pointer, say) to Haskell and have Haskell do the Right
397 Thing when it no longer references the object. So, for example, C
398 could pass a large bitmap over to Haskell and say “please free this
399 memory when you're done with it.”
403 Please see <xref LinkEnd="sec-ForeignObj"> for more details.
411 The libraries documentatation gives more details on all these
412 “primitive array” types and the operations on them.
418 <sect1 id="pattern-guards">
419 <title>Pattern guards</title>
422 <indexterm><primary>Pattern guards (Glasgow extension)</primary></indexterm>
423 The discussion that follows is an abbreviated version of Simon Peyton Jones's original <ULink URL="http://research.microsoft.com/~simonpj/Haskell/guards.html">proposal</ULink>. (Note that the proposal was written before pattern guards were implemented, so refers to them as unimplemented.)
427 Suppose we have an abstract data type of finite maps, with a
431 lookup :: FiniteMap -> Int -> Maybe Int
434 The lookup returns <function>Nothing</function> if the supplied key is not in the domain of the mapping, and <function>(Just v)</function> otherwise,
435 where <VarName>v</VarName> is the value that the key maps to. Now consider the following definition:
439 clunky env var1 var2 | ok1 && ok2 = val1 + val2
440 | otherwise = var1 + var2
451 The auxiliary functions are
455 maybeToBool :: Maybe a -> Bool
456 maybeToBool (Just x) = True
457 maybeToBool Nothing = False
459 expectJust :: Maybe a -> a
460 expectJust (Just x) = x
461 expectJust Nothing = error "Unexpected Nothing"
465 What is <function>clunky</function> doing? The guard <literal>ok1 &&
466 ok2</literal> checks that both lookups succeed, using
467 <function>maybeToBool</function> to convert the <function>Maybe</function>
468 types to booleans. The (lazily evaluated) <function>expectJust</function>
469 calls extract the values from the results of the lookups, and binds the
470 returned values to <VarName>val1</VarName> and <VarName>val2</VarName>
471 respectively. If either lookup fails, then clunky takes the
472 <literal>otherwise</literal> case and returns the sum of its arguments.
476 This is certainly legal Haskell, but it is a tremendously verbose and
477 un-obvious way to achieve the desired effect. Arguably, a more direct way
478 to write clunky would be to use case expressions:
482 clunky env var1 var1 = case lookup env var1 of
484 Just val1 -> case lookup env var2 of
486 Just val2 -> val1 + val2
492 This is a bit shorter, but hardly better. Of course, we can rewrite any set
493 of pattern-matching, guarded equations as case expressions; that is
494 precisely what the compiler does when compiling equations! The reason that
495 Haskell provides guarded equations is because they allow us to write down
496 the cases we want to consider, one at a time, independently of each other.
497 This structure is hidden in the case version. Two of the right-hand sides
498 are really the same (<function>fail</function>), and the whole expression
499 tends to become more and more indented.
503 Here is how I would write clunky:
508 | Just val1 <- lookup env var1
509 , Just val2 <- lookup env var2
511 ...other equations for clunky...
515 The semantics should be clear enough. The qualifers are matched in order.
516 For a <literal><-</literal> qualifier, which I call a pattern guard, the
517 right hand side is evaluated and matched against the pattern on the left.
518 If the match fails then the whole guard fails and the next equation is
519 tried. If it succeeds, then the appropriate binding takes place, and the
520 next qualifier is matched, in the augmented environment. Unlike list
521 comprehensions, however, the type of the expression to the right of the
522 <literal><-</literal> is the same as the type of the pattern to its
523 left. The bindings introduced by pattern guards scope over all the
524 remaining guard qualifiers, and over the right hand side of the equation.
528 Just as with list comprehensions, boolean expressions can be freely mixed
529 with among the pattern guards. For example:
540 Haskell's current guards therefore emerge as a special case, in which the
541 qualifier list has just one element, a boolean expression.
545 <sect1 id="parallel-list-comprehensions">
546 <title>Parallel List Comprehensions</title>
547 <indexterm><primary>list comprehensions</primary><secondary>parallel</secondary>
549 <indexterm><primary>parallel list comprehensions</primary>
552 <para>Parallel list comprehensions are a natural extension to list
553 comprehensions. List comprehensions can be thought of as a nice
554 syntax for writing maps and filters. Parallel comprehensions
555 extend this to include the zipWith family.</para>
557 <para>A parallel list comprehension has multiple independent
558 branches of qualifier lists, each separated by a `|' symbol. For
559 example, the following zips together two lists:</para>
562 [ (x, y) | x <- xs | y <- ys ]
565 <para>The behavior of parallel list comprehensions follows that of
566 zip, in that the resulting list will have the same length as the
567 shortest branch.</para>
569 <para>We can define parallel list comprehensions by translation to
570 regular comprehensions. Here's the basic idea:</para>
572 <para>Given a parallel comprehension of the form: </para>
575 [ e | p1 <- e11, p2 <- e12, ...
576 | q1 <- e21, q2 <- e22, ...
581 <para>This will be translated to: </para>
584 [ e | ((p1,p2), (q1,q2), ...) <- zipN [(p1,p2) | p1 <- e11, p2 <- e12, ...]
585 [(q1,q2) | q1 <- e21, q2 <- e22, ...]
590 <para>where `zipN' is the appropriate zip for the given number of
596 <title>The foreign interface</title>
598 <para>The foreign interface consists of the following components:</para>
602 <para>The Foreign Function Interface language specification
603 (included in this manual, in <xref linkend="ffi">).</para>
607 <para>The <literal>Foreign</literal> module (see <xref
608 linkend="sec-Foreign">) collects together several interfaces
609 which are useful in specifying foreign language
610 interfaces, including the following:</para>
614 <para>The <literal>ForeignObj</literal> module (see <xref
615 linkend="sec-ForeignObj">), for managing pointers from
616 Haskell into the outside world.</para>
620 <para>The <literal>StablePtr</literal> module (see <xref
621 linkend="sec-stable-pointers">), for managing pointers
622 into Haskell from the outside world.</para>
626 <para>The <literal>CTypes</literal> module (see <xref
627 linkend="sec-CTypes">) gives Haskell equivalents for the
628 standard C datatypes, for use in making Haskell bindings
629 to existing C libraries.</para>
633 <para>The <literal>CTypesISO</literal> module (see <xref
634 linkend="sec-CTypesISO">) gives Haskell equivalents for C
635 types defined by the ISO C standard.</para>
639 <para>The <literal>Storable</literal> library, for
640 primitive marshalling of data types between Haskell and
641 the foreign language.</para>
648 <para>The following sections also give some hints and tips on the use
649 of the foreign function interface in GHC.</para>
651 <sect2 id="glasgow-foreign-headers">
652 <title>Using function headers
656 <indexterm><primary>C calls, function headers</primary></indexterm>
660 When generating C (using the <option>-fvia-C</option> directive), one can assist the
661 C compiler in detecting type errors by using the <Command>-#include</Command> directive
662 to provide <filename>.h</filename> files containing function headers.
674 void initialiseEFS (HsInt size);
675 HsInt terminateEFS (void);
676 HsForeignObj emptyEFS(void);
677 HsForeignObj updateEFS (HsForeignObj a, HsInt i, HsInt x);
678 HsInt lookupEFS (HsForeignObj a, HsInt i);
682 <para>The types <literal>HsInt</literal>,
683 <literal>HsForeignObj</literal> etc. are described in <xref
684 linkend="sec-mapping-table">.</para>
686 <para>Note that this approach is only
687 <emphasis>essential</emphasis> for returning
688 <literal>float</literal>s (or if <literal>sizeof(int) !=
689 sizeof(int *)</literal> on your architecture) but is a Good
690 Thing for anyone who cares about writing solid code. You're
691 crazy not to do it.</para>
697 <sect1 id="multi-param-type-classes">
698 <title>Multi-parameter type classes
702 This section documents GHC's implementation of multi-parameter type
703 classes. There's lots of background in the paper <ULink
704 URL="http://research.microsoft.com/~simonpj/multi.ps.gz" >Type
705 classes: exploring the design space</ULink > (Simon Peyton Jones, Mark
710 I'd like to thank people who reported shorcomings in the GHC 3.02
711 implementation. Our default decisions were all conservative ones, and
712 the experience of these heroic pioneers has given useful concrete
713 examples to support several generalisations. (These appear below as
714 design choices not implemented in 3.02.)
718 I've discussed these notes with Mark Jones, and I believe that Hugs
719 will migrate towards the same design choices as I outline here.
720 Thanks to him, and to many others who have offered very useful
728 There are the following restrictions on the form of a qualified
735 forall tv1..tvn (c1, ...,cn) => type
741 (Here, I write the "foralls" explicitly, although the Haskell source
742 language omits them; in Haskell 1.4, all the free type variables of an
743 explicit source-language type signature are universally quantified,
744 except for the class type variables in a class declaration. However,
745 in GHC, you can give the foralls if you want. See <xref LinkEnd="universal-quantification">).
754 <emphasis>Each universally quantified type variable
755 <literal>tvi</literal> must be mentioned (i.e. appear free) in <literal>type</literal></emphasis>.
757 The reason for this is that a value with a type that does not obey
758 this restriction could not be used without introducing
759 ambiguity. Here, for example, is an illegal type:
763 forall a. Eq a => Int
767 When a value with this type was used, the constraint <literal>Eq tv</literal>
768 would be introduced where <literal>tv</literal> is a fresh type variable, and
769 (in the dictionary-translation implementation) the value would be
770 applied to a dictionary for <literal>Eq tv</literal>. The difficulty is that we
771 can never know which instance of <literal>Eq</literal> to use because we never
772 get any more information about <literal>tv</literal>.
779 <emphasis>Every constraint <literal>ci</literal> must mention at least one of the
780 universally quantified type variables <literal>tvi</literal></emphasis>.
782 For example, this type is OK because <literal>C a b</literal> mentions the
783 universally quantified type variable <literal>b</literal>:
787 forall a. C a b => burble
791 The next type is illegal because the constraint <literal>Eq b</literal> does not
792 mention <literal>a</literal>:
796 forall a. Eq b => burble
800 The reason for this restriction is milder than the other one. The
801 excluded types are never useful or necessary (because the offending
802 context doesn't need to be witnessed at this point; it can be floated
803 out). Furthermore, floating them out increases sharing. Lastly,
804 excluding them is a conservative choice; it leaves a patch of
805 territory free in case we need it later.
815 These restrictions apply to all types, whether declared in a type signature
820 Unlike Haskell 1.4, constraints in types do <emphasis>not</emphasis> have to be of
821 the form <emphasis>(class type-variables)</emphasis>. Thus, these type signatures
828 f :: Eq (m a) => [m a] -> [m a]
835 This choice recovers principal types, a property that Haskell 1.4 does not have.
841 <title>Class declarations</title>
849 <emphasis>Multi-parameter type classes are permitted</emphasis>. For example:
853 class Collection c a where
854 union :: c a -> c a -> c a
865 <emphasis>The class hierarchy must be acyclic</emphasis>. However, the definition
866 of "acyclic" involves only the superclass relationships. For example,
872 op :: D b => a -> b -> b
875 class C a => D a where { ... }
879 Here, <literal>C</literal> is a superclass of <literal>D</literal>, but it's OK for a
880 class operation <literal>op</literal> of <literal>C</literal> to mention <literal>D</literal>. (It
881 would not be OK for <literal>D</literal> to be a superclass of <literal>C</literal>.)
888 <emphasis>There are no restrictions on the context in a class declaration
889 (which introduces superclasses), except that the class hierarchy must
890 be acyclic</emphasis>. So these class declarations are OK:
894 class Functor (m k) => FiniteMap m k where
897 class (Monad m, Monad (t m)) => Transform t m where
898 lift :: m a -> (t m) a
907 <emphasis>In the signature of a class operation, every constraint
908 must mention at least one type variable that is not a class type
915 class Collection c a where
916 mapC :: Collection c b => (a->b) -> c a -> c b
920 is OK because the constraint <literal>(Collection a b)</literal> mentions
921 <literal>b</literal>, even though it also mentions the class variable
922 <literal>a</literal>. On the other hand:
927 op :: Eq a => (a,b) -> (a,b)
931 is not OK because the constraint <literal>(Eq a)</literal> mentions on the class
932 type variable <literal>a</literal>, but not <literal>b</literal>. However, any such
933 example is easily fixed by moving the offending context up to the
938 class Eq a => C a where
943 A yet more relaxed rule would allow the context of a class-op signature
944 to mention only class type variables. However, that conflicts with
945 Rule 1(b) for types above.
952 <emphasis>The type of each class operation must mention <emphasis>all</emphasis> of
953 the class type variables</emphasis>. For example:
959 insert :: s -> a -> s
963 is not OK, because the type of <literal>empty</literal> doesn't mention
964 <literal>a</literal>. This rule is a consequence of Rule 1(a), above, for
965 types, and has the same motivation.
967 Sometimes, offending class declarations exhibit misunderstandings. For
968 example, <literal>Coll</literal> might be rewritten
974 insert :: s a -> a -> s a
978 which makes the connection between the type of a collection of
979 <literal>a</literal>'s (namely <literal>(s a)</literal>) and the element type <literal>a</literal>.
980 Occasionally this really doesn't work, in which case you can split the
988 class CollE s => Coll s a where
989 insert :: s -> a -> s
1002 <sect2 id="instance-decls">
1003 <title>Instance declarations</title>
1011 <emphasis>Instance declarations may not overlap</emphasis>. The two instance
1016 instance context1 => C type1 where ...
1017 instance context2 => C type2 where ...
1021 "overlap" if <literal>type1</literal> and <literal>type2</literal> unify
1023 However, if you give the command line option
1024 <option>-fallow-overlapping-instances</option><indexterm><primary>-fallow-overlapping-instances
1025 option</primary></indexterm> then two overlapping instance declarations are permitted
1033 EITHER <literal>type1</literal> and <literal>type2</literal> do not unify
1039 OR <literal>type2</literal> is a substitution instance of <literal>type1</literal>
1040 (but not identical to <literal>type1</literal>)
1053 Notice that these rules
1060 make it clear which instance decl to use
1061 (pick the most specific one that matches)
1068 do not mention the contexts <literal>context1</literal>, <literal>context2</literal>
1069 Reason: you can pick which instance decl
1070 "matches" based on the type.
1077 Regrettably, GHC doesn't guarantee to detect overlapping instance
1078 declarations if they appear in different modules. GHC can "see" the
1079 instance declarations in the transitive closure of all the modules
1080 imported by the one being compiled, so it can "see" all instance decls
1081 when it is compiling <literal>Main</literal>. However, it currently chooses not
1082 to look at ones that can't possibly be of use in the module currently
1083 being compiled, in the interests of efficiency. (Perhaps we should
1084 change that decision, at least for <literal>Main</literal>.)
1091 <emphasis>There are no restrictions on the type in an instance
1092 <emphasis>head</emphasis>, except that at least one must not be a type variable</emphasis>.
1093 The instance "head" is the bit after the "=>" in an instance decl. For
1094 example, these are OK:
1098 instance C Int a where ...
1100 instance D (Int, Int) where ...
1102 instance E [[a]] where ...
1106 Note that instance heads <emphasis>may</emphasis> contain repeated type variables.
1107 For example, this is OK:
1111 instance Stateful (ST s) (MutVar s) where ...
1115 The "at least one not a type variable" restriction is to ensure that
1116 context reduction terminates: each reduction step removes one type
1117 constructor. For example, the following would make the type checker
1118 loop if it wasn't excluded:
1122 instance C a => C a where ...
1126 There are two situations in which the rule is a bit of a pain. First,
1127 if one allows overlapping instance declarations then it's quite
1128 convenient to have a "default instance" declaration that applies if
1129 something more specific does not:
1138 Second, sometimes you might want to use the following to get the
1139 effect of a "class synonym":
1143 class (C1 a, C2 a, C3 a) => C a where { }
1145 instance (C1 a, C2 a, C3 a) => C a where { }
1149 This allows you to write shorter signatures:
1161 f :: (C1 a, C2 a, C3 a) => ...
1165 I'm on the lookout for a simple rule that preserves decidability while
1166 allowing these idioms. The experimental flag
1167 <option>-fallow-undecidable-instances</option><indexterm><primary>-fallow-undecidable-instances
1168 option</primary></indexterm> lifts this restriction, allowing all the types in an
1169 instance head to be type variables.
1176 <emphasis>Unlike Haskell 1.4, instance heads may use type
1177 synonyms</emphasis>. As always, using a type synonym is just shorthand for
1178 writing the RHS of the type synonym definition. For example:
1182 type Point = (Int,Int)
1183 instance C Point where ...
1184 instance C [Point] where ...
1188 is legal. However, if you added
1192 instance C (Int,Int) where ...
1196 as well, then the compiler will complain about the overlapping
1197 (actually, identical) instance declarations. As always, type synonyms
1198 must be fully applied. You cannot, for example, write:
1203 instance Monad P where ...
1207 This design decision is independent of all the others, and easily
1208 reversed, but it makes sense to me.
1215 <emphasis>The types in an instance-declaration <emphasis>context</emphasis> must all
1216 be type variables</emphasis>. Thus
1220 instance C a b => Eq (a,b) where ...
1228 instance C Int b => Foo b where ...
1232 is not OK. Again, the intent here is to make sure that context
1233 reduction terminates.
1235 Voluminous correspondence on the Haskell mailing list has convinced me
1236 that it's worth experimenting with a more liberal rule. If you use
1237 the flag <option>-fallow-undecidable-instances</option> can use arbitrary
1238 types in an instance context. Termination is ensured by having a
1239 fixed-depth recursion stack. If you exceed the stack depth you get a
1240 sort of backtrace, and the opportunity to increase the stack depth
1241 with <option>-fcontext-stack</option><emphasis>N</emphasis>.
1254 <sect1 id="implicit-parameters">
1255 <title>Implicit parameters
1258 <para> Implicit paramters are implemented as described in
1259 "Implicit parameters: dynamic scoping with static types",
1260 J Lewis, MB Shields, E Meijer, J Launchbury,
1261 27th ACM Symposium on Principles of Programming Languages (POPL'00),
1266 There should be more documentation, but there isn't (yet). Yell if you need it.
1270 <para> You can't have an implicit parameter in the context of a class or instance
1271 declaration. For example, both these declarations are illegal:
1273 class (?x::Int) => C a where ...
1274 instance (?x::a) => Foo [a] where ...
1276 Reason: exactly which implicit parameter you pick up depends on exactly where
1277 you invoke a function. But the ``invocation'' of instance declarations is done
1278 behind the scenes by the compiler, so it's hard to figure out exactly where it is done.
1279 Easiest thing is to outlaw the offending types.</para>
1287 <sect1 id="functional-dependencies">
1288 <title>Functional dependencies
1291 <para> Functional dependencies are implemented as described by Mark Jones
1292 in "Type Classes with Functional Dependencies", Mark P. Jones,
1293 In Proceedings of the 9th European Symposium on Programming,
1294 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782.
1298 There should be more documentation, but there isn't (yet). Yell if you need it.
1303 <sect1 id="universal-quantification">
1304 <title>Explicit universal quantification
1308 GHC's type system supports explicit universal quantification in
1309 constructor fields and function arguments. This is useful for things
1310 like defining <literal>runST</literal> from the state-thread world.
1311 GHC's syntax for this now agrees with Hugs's, namely:
1317 forall a b. (Ord a, Eq b) => a -> b -> a
1323 The context is, of course, optional. You can't use <literal>forall</literal> as
1324 a type variable any more!
1328 Haskell type signatures are implicitly quantified. The <literal>forall</literal>
1329 allows us to say exactly what this means. For example:
1347 g :: forall b. (b -> b)
1353 The two are treated identically.
1357 <title>Universally-quantified data type fields
1361 In a <literal>data</literal> or <literal>newtype</literal> declaration one can quantify
1362 the types of the constructor arguments. Here are several examples:
1368 data T a = T1 (forall b. b -> b -> b) a
1370 data MonadT m = MkMonad { return :: forall a. a -> m a,
1371 bind :: forall a b. m a -> (a -> m b) -> m b
1374 newtype Swizzle = MkSwizzle (Ord a => [a] -> [a])
1380 The constructors now have so-called <emphasis>rank 2</emphasis> polymorphic
1381 types, in which there is a for-all in the argument types.:
1387 T1 :: forall a. (forall b. b -> b -> b) -> a -> T a
1388 MkMonad :: forall m. (forall a. a -> m a)
1389 -> (forall a b. m a -> (a -> m b) -> m b)
1391 MkSwizzle :: (Ord a => [a] -> [a]) -> Swizzle
1397 Notice that you don't need to use a <literal>forall</literal> if there's an
1398 explicit context. For example in the first argument of the
1399 constructor <function>MkSwizzle</function>, an implicit "<literal>forall a.</literal>" is
1400 prefixed to the argument type. The implicit <literal>forall</literal>
1401 quantifies all type variables that are not already in scope, and are
1402 mentioned in the type quantified over.
1406 As for type signatures, implicit quantification happens for non-overloaded
1407 types too. So if you write this:
1410 data T a = MkT (Either a b) (b -> b)
1413 it's just as if you had written this:
1416 data T a = MkT (forall b. Either a b) (forall b. b -> b)
1419 That is, since the type variable <literal>b</literal> isn't in scope, it's
1420 implicitly universally quantified. (Arguably, it would be better
1421 to <emphasis>require</emphasis> explicit quantification on constructor arguments
1422 where that is what is wanted. Feedback welcomed.)
1428 <title>Construction </title>
1431 You construct values of types <literal>T1, MonadT, Swizzle</literal> by applying
1432 the constructor to suitable values, just as usual. For example,
1438 (T1 (\xy->x) 3) :: T Int
1440 (MkSwizzle sort) :: Swizzle
1441 (MkSwizzle reverse) :: Swizzle
1448 MkMonad r b) :: MonadT Maybe
1454 The type of the argument can, as usual, be more general than the type
1455 required, as <literal>(MkSwizzle reverse)</literal> shows. (<function>reverse</function>
1456 does not need the <literal>Ord</literal> constraint.)
1462 <title>Pattern matching</title>
1465 When you use pattern matching, the bound variables may now have
1466 polymorphic types. For example:
1472 f :: T a -> a -> (a, Char)
1473 f (T1 f k) x = (f k x, f 'c' 'd')
1475 g :: (Ord a, Ord b) => Swizzle -> [a] -> (a -> b) -> [b]
1476 g (MkSwizzle s) xs f = s (map f (s xs))
1478 h :: MonadT m -> [m a] -> m [a]
1479 h m [] = return m []
1480 h m (x:xs) = bind m x $ \y ->
1481 bind m (h m xs) $ \ys ->
1488 In the function <function>h</function> we use the record selectors <literal>return</literal>
1489 and <literal>bind</literal> to extract the polymorphic bind and return functions
1490 from the <literal>MonadT</literal> data structure, rather than using pattern
1495 You cannot pattern-match against an argument that is polymorphic.
1499 newtype TIM s a = TIM (ST s (Maybe a))
1501 runTIM :: (forall s. TIM s a) -> Maybe a
1502 runTIM (TIM m) = runST m
1508 Here the pattern-match fails, because you can't pattern-match against
1509 an argument of type <literal>(forall s. TIM s a)</literal>. Instead you
1510 must bind the variable and pattern match in the right hand side:
1513 runTIM :: (forall s. TIM s a) -> Maybe a
1514 runTIM tm = case tm of { TIM m -> runST m }
1517 The <literal>tm</literal> on the right hand side is (invisibly) instantiated, like
1518 any polymorphic value at its occurrence site, and now you can pattern-match
1525 <title>The partial-application restriction</title>
1528 There is really only one way in which data structures with polymorphic
1529 components might surprise you: you must not partially apply them.
1530 For example, this is illegal:
1536 map MkSwizzle [sort, reverse]
1542 The restriction is this: <emphasis>every subexpression of the program must
1543 have a type that has no for-alls, except that in a function
1544 application (f e1…en) the partial applications are not subject to
1545 this rule</emphasis>. The restriction makes type inference feasible.
1549 In the illegal example, the sub-expression <literal>MkSwizzle</literal> has the
1550 polymorphic type <literal>(Ord b => [b] -> [b]) -> Swizzle</literal> and is not
1551 a sub-expression of an enclosing application. On the other hand, this
1558 map (T1 (\a b -> a)) [1,2,3]
1564 even though it involves a partial application of <function>T1</function>, because
1565 the sub-expression <literal>T1 (\a b -> a)</literal> has type <literal>Int -> T
1572 <title>Type signatures
1576 Once you have data constructors with universally-quantified fields, or
1577 constants such as <Constant>runST</Constant> that have rank-2 types, it isn't long
1578 before you discover that you need more! Consider:
1584 mkTs f x y = [T1 f x, T1 f y]
1590 <function>mkTs</function> is a fuction that constructs some values of type
1591 <literal>T</literal>, using some pieces passed to it. The trouble is that since
1592 <literal>f</literal> is a function argument, Haskell assumes that it is
1593 monomorphic, so we'll get a type error when applying <function>T1</function> to
1594 it. This is a rather silly example, but the problem really bites in
1595 practice. Lots of people trip over the fact that you can't make
1596 "wrappers functions" for <Constant>runST</Constant> for exactly the same reason.
1597 In short, it is impossible to build abstractions around functions with
1602 The solution is fairly clear. We provide the ability to give a rank-2
1603 type signature for <emphasis>ordinary</emphasis> functions (not only data
1604 constructors), thus:
1610 mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1611 mkTs f x y = [T1 f x, T1 f y]
1617 This type signature tells the compiler to attribute <literal>f</literal> with
1618 the polymorphic type <literal>(forall b. b -> b -> b)</literal> when type
1619 checking the body of <function>mkTs</function>, so now the application of
1620 <function>T1</function> is fine.
1624 There are two restrictions:
1633 You can only define a rank 2 type, specified by the following
1638 rank2type ::= [forall tyvars .] [context =>] funty
1639 funty ::= ([forall tyvars .] [context =>] ty) -> funty
1641 ty ::= ...current Haskell monotype syntax...
1645 Informally, the universal quantification must all be right at the beginning,
1646 or at the top level of a function argument.
1653 There is a restriction on the definition of a function whose
1654 type signature is a rank-2 type: the polymorphic arguments must be
1655 matched on the left hand side of the "<literal>=</literal>" sign. You can't
1656 define <function>mkTs</function> like this:
1660 mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1661 mkTs = \ f x y -> [T1 f x, T1 f y]
1666 The same partial-application rule applies to ordinary functions with
1667 rank-2 types as applied to data constructors.
1680 <title>Type synonyms and hoisting
1684 GHC also allows you to write a <literal>forall</literal> in a type synonym, thus:
1686 type Discard a = forall b. a -> b -> a
1691 However, it is often convenient to use these sort of synonyms at the right hand
1692 end of an arrow, thus:
1694 type Discard a = forall b. a -> b -> a
1696 g :: Int -> Discard Int
1699 Simply expanding the type synonym would give
1701 g :: Int -> (forall b. Int -> b -> Int)
1703 but GHC "hoists" the <literal>forall</literal> to give the isomorphic type
1705 g :: forall b. Int -> Int -> b -> Int
1707 In general, the rule is this: <emphasis>to determine the type specified by any explicit
1708 user-written type (e.g. in a type signature), GHC expands type synonyms and then repeatedly
1709 performs the transformation:</emphasis>
1711 <emphasis>type1</emphasis> -> forall a. <emphasis>type2</emphasis>
1713 forall a. <emphasis>type1</emphasis> -> <emphasis>type2</emphasis>
1715 (In fact, GHC tries to retain as much synonym information as possible for use in
1716 error messages, but that is a usability issue.) This rule applies, of course, whether
1717 or not the <literal>forall</literal> comes from a synonym. For example, here is another
1718 valid way to write <literal>g</literal>'s type signature:
1720 g :: Int -> Int -> forall b. b -> Int
1727 <sect1 id="existential-quantification">
1728 <title>Existentially quantified data constructors
1732 The idea of using existential quantification in data type declarations
1733 was suggested by Laufer (I believe, thought doubtless someone will
1734 correct me), and implemented in Hope+. It's been in Lennart
1735 Augustsson's <Command>hbc</Command> Haskell compiler for several years, and
1736 proved very useful. Here's the idea. Consider the declaration:
1742 data Foo = forall a. MkFoo a (a -> Bool)
1749 The data type <literal>Foo</literal> has two constructors with types:
1755 MkFoo :: forall a. a -> (a -> Bool) -> Foo
1762 Notice that the type variable <literal>a</literal> in the type of <function>MkFoo</function>
1763 does not appear in the data type itself, which is plain <literal>Foo</literal>.
1764 For example, the following expression is fine:
1770 [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
1776 Here, <literal>(MkFoo 3 even)</literal> packages an integer with a function
1777 <function>even</function> that maps an integer to <literal>Bool</literal>; and <function>MkFoo 'c'
1778 isUpper</function> packages a character with a compatible function. These
1779 two things are each of type <literal>Foo</literal> and can be put in a list.
1783 What can we do with a value of type <literal>Foo</literal>?. In particular,
1784 what happens when we pattern-match on <function>MkFoo</function>?
1790 f (MkFoo val fn) = ???
1796 Since all we know about <literal>val</literal> and <function>fn</function> is that they
1797 are compatible, the only (useful) thing we can do with them is to
1798 apply <function>fn</function> to <literal>val</literal> to get a boolean. For example:
1805 f (MkFoo val fn) = fn val
1811 What this allows us to do is to package heterogenous values
1812 together with a bunch of functions that manipulate them, and then treat
1813 that collection of packages in a uniform manner. You can express
1814 quite a bit of object-oriented-like programming this way.
1817 <sect2 id="existential">
1818 <title>Why existential?
1822 What has this to do with <emphasis>existential</emphasis> quantification?
1823 Simply that <function>MkFoo</function> has the (nearly) isomorphic type
1829 MkFoo :: (exists a . (a, a -> Bool)) -> Foo
1835 But Haskell programmers can safely think of the ordinary
1836 <emphasis>universally</emphasis> quantified type given above, thereby avoiding
1837 adding a new existential quantification construct.
1843 <title>Type classes</title>
1846 An easy extension (implemented in <Command>hbc</Command>) is to allow
1847 arbitrary contexts before the constructor. For example:
1853 data Baz = forall a. Eq a => Baz1 a a
1854 | forall b. Show b => Baz2 b (b -> b)
1860 The two constructors have the types you'd expect:
1866 Baz1 :: forall a. Eq a => a -> a -> Baz
1867 Baz2 :: forall b. Show b => b -> (b -> b) -> Baz
1873 But when pattern matching on <function>Baz1</function> the matched values can be compared
1874 for equality, and when pattern matching on <function>Baz2</function> the first matched
1875 value can be converted to a string (as well as applying the function to it).
1876 So this program is legal:
1883 f (Baz1 p q) | p == q = "Yes"
1885 f (Baz1 v fn) = show (fn v)
1891 Operationally, in a dictionary-passing implementation, the
1892 constructors <function>Baz1</function> and <function>Baz2</function> must store the
1893 dictionaries for <literal>Eq</literal> and <literal>Show</literal> respectively, and
1894 extract it on pattern matching.
1898 Notice the way that the syntax fits smoothly with that used for
1899 universal quantification earlier.
1905 <title>Restrictions</title>
1908 There are several restrictions on the ways in which existentially-quantified
1909 constructors can be use.
1918 When pattern matching, each pattern match introduces a new,
1919 distinct, type for each existential type variable. These types cannot
1920 be unified with any other type, nor can they escape from the scope of
1921 the pattern match. For example, these fragments are incorrect:
1929 Here, the type bound by <function>MkFoo</function> "escapes", because <literal>a</literal>
1930 is the result of <function>f1</function>. One way to see why this is wrong is to
1931 ask what type <function>f1</function> has:
1935 f1 :: Foo -> a -- Weird!
1939 What is this "<literal>a</literal>" in the result type? Clearly we don't mean
1944 f1 :: forall a. Foo -> a -- Wrong!
1948 The original program is just plain wrong. Here's another sort of error
1952 f2 (Baz1 a b) (Baz1 p q) = a==q
1956 It's ok to say <literal>a==b</literal> or <literal>p==q</literal>, but
1957 <literal>a==q</literal> is wrong because it equates the two distinct types arising
1958 from the two <function>Baz1</function> constructors.
1966 You can't pattern-match on an existentially quantified
1967 constructor in a <literal>let</literal> or <literal>where</literal> group of
1968 bindings. So this is illegal:
1972 f3 x = a==b where { Baz1 a b = x }
1976 You can only pattern-match
1977 on an existentially-quantified constructor in a <literal>case</literal> expression or
1978 in the patterns of a function definition.
1980 The reason for this restriction is really an implementation one.
1981 Type-checking binding groups is already a nightmare without
1982 existentials complicating the picture. Also an existential pattern
1983 binding at the top level of a module doesn't make sense, because it's
1984 not clear how to prevent the existentially-quantified type "escaping".
1985 So for now, there's a simple-to-state restriction. We'll see how
1993 You can't use existential quantification for <literal>newtype</literal>
1994 declarations. So this is illegal:
1998 newtype T = forall a. Ord a => MkT a
2002 Reason: a value of type <literal>T</literal> must be represented as a pair
2003 of a dictionary for <literal>Ord t</literal> and a value of type <literal>t</literal>.
2004 That contradicts the idea that <literal>newtype</literal> should have no
2005 concrete representation. You can get just the same efficiency and effect
2006 by using <literal>data</literal> instead of <literal>newtype</literal>. If there is no
2007 overloading involved, then there is more of a case for allowing
2008 an existentially-quantified <literal>newtype</literal>, because the <literal>data</literal>
2009 because the <literal>data</literal> version does carry an implementation cost,
2010 but single-field existentially quantified constructors aren't much
2011 use. So the simple restriction (no existential stuff on <literal>newtype</literal>)
2012 stands, unless there are convincing reasons to change it.
2020 You can't use <literal>deriving</literal> to define instances of a
2021 data type with existentially quantified data constructors.
2023 Reason: in most cases it would not make sense. For example:#
2026 data T = forall a. MkT [a] deriving( Eq )
2029 To derive <literal>Eq</literal> in the standard way we would need to have equality
2030 between the single component of two <function>MkT</function> constructors:
2034 (MkT a) == (MkT b) = ???
2037 But <VarName>a</VarName> and <VarName>b</VarName> have distinct types, and so can't be compared.
2038 It's just about possible to imagine examples in which the derived instance
2039 would make sense, but it seems altogether simpler simply to prohibit such
2040 declarations. Define your own instances!
2052 <sect1 id="sec-assertions">
2054 <indexterm><primary>Assertions</primary></indexterm>
2058 If you want to make use of assertions in your standard Haskell code, you
2059 could define a function like the following:
2065 assert :: Bool -> a -> a
2066 assert False x = error "assertion failed!"
2073 which works, but gives you back a less than useful error message --
2074 an assertion failed, but which and where?
2078 One way out is to define an extended <function>assert</function> function which also
2079 takes a descriptive string to include in the error message and
2080 perhaps combine this with the use of a pre-processor which inserts
2081 the source location where <function>assert</function> was used.
2085 Ghc offers a helping hand here, doing all of this for you. For every
2086 use of <function>assert</function> in the user's source:
2092 kelvinToC :: Double -> Double
2093 kelvinToC k = assert (k >= 0.0) (k+273.15)
2099 Ghc will rewrite this to also include the source location where the
2106 assert pred val ==> assertError "Main.hs|15" pred val
2112 The rewrite is only performed by the compiler when it spots
2113 applications of <function>Exception.assert</function>, so you can still define and
2114 use your own versions of <function>assert</function>, should you so wish. If not,
2115 import <literal>Exception</literal> to make use <function>assert</function> in your code.
2119 To have the compiler ignore uses of assert, use the compiler option
2120 <option>-fignore-asserts</option>. <indexterm><primary>-fignore-asserts option</primary></indexterm> That is,
2121 expressions of the form <literal>assert pred e</literal> will be rewritten to <literal>e</literal>.
2125 Assertion failures can be caught, see the documentation for the
2126 <literal>Exception</literal> library (<xref linkend="sec-Exception">)
2132 <sect1 id="scoped-type-variables">
2133 <title>Scoped Type Variables
2137 A <emphasis>pattern type signature</emphasis> can introduce a <emphasis>scoped type
2138 variable</emphasis>. For example
2144 f (xs::[a]) = ys ++ ys
2153 The pattern <literal>(xs::[a])</literal> includes a type signature for <VarName>xs</VarName>.
2154 This brings the type variable <literal>a</literal> into scope; it scopes over
2155 all the patterns and right hand sides for this equation for <function>f</function>.
2156 In particular, it is in scope at the type signature for <VarName>y</VarName>.
2160 Pattern type signatures are completely orthogonal to ordinary, separate
2161 type signatures. The two can be used independently or together.
2162 At ordinary type signatures, such as that for <VarName>ys</VarName>, any type variables
2163 mentioned in the type signature <emphasis>that are not in scope</emphasis> are
2164 implicitly universally quantified. (If there are no type variables in
2165 scope, all type variables mentioned in the signature are universally
2166 quantified, which is just as in Haskell 98.) In this case, since <VarName>a</VarName>
2167 is in scope, it is not universally quantified, so the type of <VarName>ys</VarName> is
2168 the same as that of <VarName>xs</VarName>. In Haskell 98 it is not possible to declare
2169 a type for <VarName>ys</VarName>; a major benefit of scoped type variables is that
2170 it becomes possible to do so.
2174 Scoped type variables are implemented in both GHC and Hugs. Where the
2175 implementations differ from the specification below, those differences
2180 So much for the basic idea. Here are the details.
2184 <title>What a pattern type signature means</title>
2186 A type variable brought into scope by a pattern type signature is simply
2187 the name for a type. The restriction they express is that all occurrences
2188 of the same name mean the same type. For example:
2190 f :: [Int] -> Int -> Int
2191 f (xs::[a]) (y::a) = (head xs + y) :: a
2193 The pattern type signatures on the left hand side of
2194 <literal>f</literal> express the fact that <literal>xs</literal>
2195 must be a list of things of some type <literal>a</literal>; and that <literal>y</literal>
2196 must have this same type. The type signature on the expression <literal>(head xs)</literal>
2197 specifies that this expression must have the same type <literal>a</literal>.
2198 <emphasis>There is no requirement that the type named by "<literal>a</literal>" is
2199 in fact a type variable. Indeed, in this case, the type named by "<literal>a</literal>" is
2200 <literal>Int</literal>. (This is a slight liberalisation from the original rather complex
2201 rules, which specified that a pattern-bound type variable should be universally quantified.)
2202 For example, all of these are legal:
2205 t (x::a) (y::a) = x+y*2
2207 f (x::a) (y::b) = [x,y] -- a unifies with b
2209 g (x::a) = x + 1::Int -- a unifies with Int
2211 h x = let k (y::a) = [x,y] -- a is free in the
2212 in k x -- environment
2214 k (x::a) True = ... -- a unifies with Int
2215 k (x::Int) False = ...
2218 w (x::a) = x -- a unifies with [b]
2225 <title>Scope and implicit quantification</title>
2233 All the type variables mentioned in a pattern,
2234 that are not already in scope,
2235 are brought into scope by the pattern. We describe this set as
2236 the <emphasis>type variables bound by the pattern</emphasis>.
2243 The type variables thus brought into scope may be mentioned
2244 in ordinary type signatures or pattern type signatures anywhere within
2252 In ordinary type signatures, any type variable mentioned in the
2253 signature that is in scope is <emphasis>not</emphasis> universally quantified.
2261 Ordinary type signatures do not bring any new type variables
2262 into scope (except in the type signature itself!). So this is illegal:
2271 It's illegal because <VarName>a</VarName> is not in scope in the body of <function>f</function>,
2272 so the ordinary signature <literal>x::a</literal> is equivalent to <literal>x::forall a.a</literal>;
2273 and that is an incorrect typing.
2280 There is no implicit universal quantification on pattern type
2281 signatures, nor may one write an explicit <literal>forall</literal> type in a pattern
2282 type signature. The pattern type signature is a monotype.
2290 The type variables in the head of a <literal>class</literal> or <literal>instance</literal> declaration
2291 scope over the methods defined in the <literal>where</literal> part. For example:
2305 (Not implemented in Hugs yet, Dec 98).
2316 <title>Result type signatures</title>
2324 The result type of a function can be given a signature,
2329 f (x::a) :: [a] = [x,x,x]
2333 The final <literal>:: [a]</literal> after all the patterns gives a signature to the
2334 result type. Sometimes this is the only way of naming the type variable
2339 f :: Int -> [a] -> [a]
2340 f n :: ([a] -> [a]) = let g (x::a, y::a) = (y,x)
2341 in \xs -> map g (reverse xs `zip` xs)
2353 Result type signatures are not yet implemented in Hugs.
2359 <title>Where a pattern type signature can occur</title>
2361 A pattern type signature can occur in any pattern, but there
2362 are restrictions on pattern bindings:
2367 A pattern type signature can be on an arbitrary sub-pattern, not
2372 f ((x,y)::(a,b)) = (y,x) :: (b,a)
2381 Pattern type signatures, including the result part, can be used
2382 in lambda abstractions:
2385 (\ (x::a, y) :: a -> x)
2392 Pattern type signatures, including the result part, can be used
2393 in <literal>case</literal> expressions:
2397 case e of { (x::a, y) :: a -> x }
2405 To avoid ambiguity, the type after the “<literal>::</literal>” in a result
2406 pattern signature on a lambda or <literal>case</literal> must be atomic (i.e. a single
2407 token or a parenthesised type of some sort). To see why,
2408 consider how one would parse this:
2422 Pattern type signatures can bind existential type variables.
2427 data T = forall a. MkT [a]
2430 f (MkT [t::a]) = MkT t3
2443 Pattern type signatures that bind new type variables
2444 may not be used in pattern bindings at all.
2449 f x = let (y, z::a) = x in ...
2453 But these are OK, because they do not bind fresh type variables:
2457 f1 x = let (y, z::Int) = x in ...
2458 f2 (x::(Int,a)) = let (y, z::a) = x in ...
2462 However a single variable is considered a degenerate function binding,
2463 rather than a degerate pattern binding, so this is permitted, even
2464 though it binds a type variable:
2468 f :: (b->b) = \(x::b) -> x
2477 Such degnerate function bindings do not fall under the monomorphism
2484 g :: a -> a -> Bool = \x y. x==y
2490 Here <function>g</function> has type <literal>forall a. Eq a => a -> a -> Bool</literal>, just as if
2491 <function>g</function> had a separate type signature. Lacking a type signature, <function>g</function>
2492 would get a monomorphic type.
2500 <sect1 id="pragmas">
2505 GHC supports several pragmas, or instructions to the compiler placed
2506 in the source code. Pragmas don't affect the meaning of the program,
2507 but they might affect the efficiency of the generated code.
2510 <sect2 id="inline-pragma">
2511 <title>INLINE pragma
2513 <indexterm><primary>INLINE pragma</primary></indexterm>
2514 <indexterm><primary>pragma, INLINE</primary></indexterm></title>
2517 GHC (with <option>-O</option>, as always) tries to inline (or “unfold”)
2518 functions/values that are “small enough,” thus avoiding the call
2519 overhead and possibly exposing other more-wonderful optimisations.
2523 You will probably see these unfoldings (in Core syntax) in your
2528 Normally, if GHC decides a function is “too expensive” to inline, it
2529 will not do so, nor will it export that unfolding for other modules to
2534 The sledgehammer you can bring to bear is the
2535 <literal>INLINE</literal><indexterm><primary>INLINE pragma</primary></indexterm> pragma, used thusly:
2538 key_function :: Int -> String -> (Bool, Double)
2540 #ifdef __GLASGOW_HASKELL__
2541 {-# INLINE key_function #-}
2545 (You don't need to do the C pre-processor carry-on unless you're going
2546 to stick the code through HBC—it doesn't like <literal>INLINE</literal> pragmas.)
2550 The major effect of an <literal>INLINE</literal> pragma is to declare a function's
2551 “cost” to be very low. The normal unfolding machinery will then be
2552 very keen to inline it.
2556 An <literal>INLINE</literal> pragma for a function can be put anywhere its type
2557 signature could be put.
2561 <literal>INLINE</literal> pragmas are a particularly good idea for the
2562 <literal>then</literal>/<literal>return</literal> (or <literal>bind</literal>/<literal>unit</literal>) functions in a monad.
2563 For example, in GHC's own <literal>UniqueSupply</literal> monad code, we have:
2566 #ifdef __GLASGOW_HASKELL__
2567 {-# INLINE thenUs #-}
2568 {-# INLINE returnUs #-}
2576 <sect2 id="noinline-pragma">
2577 <title>NOINLINE pragma
2581 <indexterm><primary>NOINLINE pragma</primary></indexterm>
2582 <indexterm><primary>pragma, NOINLINE</primary></indexterm>
2586 The <literal>NOINLINE</literal> pragma does exactly what you'd expect: it stops the
2587 named function from being inlined by the compiler. You shouldn't ever
2588 need to do this, unless you're very cautious about code size.
2593 <sect2 id="specialize-pragma">
2594 <title>SPECIALIZE pragma</title>
2596 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2597 <indexterm><primary>pragma, SPECIALIZE</primary></indexterm>
2598 <indexterm><primary>overloading, death to</primary></indexterm>
2600 <para>(UK spelling also accepted.) For key overloaded
2601 functions, you can create extra versions (NB: more code space)
2602 specialised to particular types. Thus, if you have an
2603 overloaded function:</para>
2606 hammeredLookup :: Ord key => [(key, value)] -> key -> value
2609 <para>If it is heavily used on lists with
2610 <literal>Widget</literal> keys, you could specialise it as
2614 {-# SPECIALIZE hammeredLookup :: [(Widget, value)] -> Widget -> value #-}
2617 <para>To get very fancy, you can also specify a named function
2618 to use for the specialised value, as in:</para>
2621 {-# RULES hammeredLookup = blah #-}
2624 <para>where <literal>blah</literal> is an implementation of
2625 <literal>hammerdLookup</literal> written specialy for
2626 <literal>Widget</literal> lookups. It's <emphasis>Your
2627 Responsibility</emphasis> to make sure that
2628 <function>blah</function> really behaves as a specialised
2629 version of <function>hammeredLookup</function>!!!</para>
2631 <para>Note we use the <literal>RULE</literal> pragma here to
2632 indicate that <literal>hammeredLookup</literal> applied at a
2633 certain type should be replaced by <literal>blah</literal>. See
2634 <xref linkend="rules"> for more information on
2635 <literal>RULES</literal>.</para>
2637 <para>An example in which using <literal>RULES</literal> for
2638 specialisation will Win Big:
2641 toDouble :: Real a => a -> Double
2642 toDouble = fromRational . toRational
2644 {-# SPECIALIZE toDouble :: Int -> Double = i2d #-}
2645 i2d (I# i) = D# (int2Double# i) -- uses Glasgow prim-op directly
2648 The <function>i2d</function> function is virtually one machine
2649 instruction; the default conversion—via an intermediate
2650 <literal>Rational</literal>—is obscenely expensive by
2653 <para>A <literal>SPECIALIZE</literal> pragma for a function can
2654 be put anywhere its type signature could be put.</para>
2658 <sect2 id="specialize-instance-pragma">
2659 <title>SPECIALIZE instance pragma
2663 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2664 <indexterm><primary>overloading, death to</primary></indexterm>
2665 Same idea, except for instance declarations. For example:
2668 instance (Eq a) => Eq (Foo a) where { ... usual stuff ... }
2670 {-# SPECIALIZE instance Eq (Foo [(Int, Bar)] #-}
2673 Compatible with HBC, by the way.
2678 <sect2 id="line-pragma">
2683 <indexterm><primary>LINE pragma</primary></indexterm>
2684 <indexterm><primary>pragma, LINE</primary></indexterm>
2688 This pragma is similar to C's <literal>#line</literal> pragma, and is mainly for use in
2689 automatically generated Haskell code. It lets you specify the line
2690 number and filename of the original code; for example
2696 {-# LINE 42 "Foo.vhs" #-}
2702 if you'd generated the current file from something called <filename>Foo.vhs</filename>
2703 and this line corresponds to line 42 in the original. GHC will adjust
2704 its error messages to refer to the line/file named in the <literal>LINE</literal>
2711 <title>RULES pragma</title>
2714 The RULES pragma lets you specify rewrite rules. It is described in
2715 <xref LinkEnd="rewrite-rules">.
2722 <sect1 id="rewrite-rules">
2723 <title>Rewrite rules
2725 <indexterm><primary>RULES pagma</primary></indexterm>
2726 <indexterm><primary>pragma, RULES</primary></indexterm>
2727 <indexterm><primary>rewrite rules</primary></indexterm></title>
2730 The programmer can specify rewrite rules as part of the source program
2731 (in a pragma). GHC applies these rewrite rules wherever it can.
2739 "map/map" forall f g xs. map f (map g xs) = map (f.g) xs
2746 <title>Syntax</title>
2749 From a syntactic point of view:
2755 Each rule has a name, enclosed in double quotes. The name itself has
2756 no significance at all. It is only used when reporting how many times the rule fired.
2762 There may be zero or more rules in a <literal>RULES</literal> pragma.
2768 Layout applies in a <literal>RULES</literal> pragma. Currently no new indentation level
2769 is set, so you must lay out your rules starting in the same column as the
2770 enclosing definitions.
2776 Each variable mentioned in a rule must either be in scope (e.g. <function>map</function>),
2777 or bound by the <literal>forall</literal> (e.g. <function>f</function>, <function>g</function>, <function>xs</function>). The variables bound by
2778 the <literal>forall</literal> are called the <emphasis>pattern</emphasis> variables. They are separated
2779 by spaces, just like in a type <literal>forall</literal>.
2785 A pattern variable may optionally have a type signature.
2786 If the type of the pattern variable is polymorphic, it <emphasis>must</emphasis> have a type signature.
2787 For example, here is the <literal>foldr/build</literal> rule:
2790 "fold/build" forall k z (g::forall b. (a->b->b) -> b -> b) .
2791 foldr k z (build g) = g k z
2794 Since <function>g</function> has a polymorphic type, it must have a type signature.
2801 The left hand side of a rule must consist of a top-level variable applied
2802 to arbitrary expressions. For example, this is <emphasis>not</emphasis> OK:
2805 "wrong1" forall e1 e2. case True of { True -> e1; False -> e2 } = e1
2806 "wrong2" forall f. f True = True
2809 In <literal>"wrong1"</literal>, the LHS is not an application; in <literal>"wrong2"</literal>, the LHS has a pattern variable
2816 A rule does not need to be in the same module as (any of) the
2817 variables it mentions, though of course they need to be in scope.
2823 Rules are automatically exported from a module, just as instance declarations are.
2834 <title>Semantics</title>
2837 From a semantic point of view:
2843 Rules are only applied if you use the <option>-O</option> flag.
2849 Rules are regarded as left-to-right rewrite rules.
2850 When GHC finds an expression that is a substitution instance of the LHS
2851 of a rule, it replaces the expression by the (appropriately-substituted) RHS.
2852 By "a substitution instance" we mean that the LHS can be made equal to the
2853 expression by substituting for the pattern variables.
2860 The LHS and RHS of a rule are typechecked, and must have the
2868 GHC makes absolutely no attempt to verify that the LHS and RHS
2869 of a rule have the same meaning. That is undecideable in general, and
2870 infeasible in most interesting cases. The responsibility is entirely the programmer's!
2877 GHC makes no attempt to make sure that the rules are confluent or
2878 terminating. For example:
2881 "loop" forall x,y. f x y = f y x
2884 This rule will cause the compiler to go into an infinite loop.
2891 If more than one rule matches a call, GHC will choose one arbitrarily to apply.
2897 GHC currently uses a very simple, syntactic, matching algorithm
2898 for matching a rule LHS with an expression. It seeks a substitution
2899 which makes the LHS and expression syntactically equal modulo alpha
2900 conversion. The pattern (rule), but not the expression, is eta-expanded if
2901 necessary. (Eta-expanding the epression can lead to laziness bugs.)
2902 But not beta conversion (that's called higher-order matching).
2906 Matching is carried out on GHC's intermediate language, which includes
2907 type abstractions and applications. So a rule only matches if the
2908 types match too. See <xref LinkEnd="rule-spec"> below.
2914 GHC keeps trying to apply the rules as it optimises the program.
2915 For example, consider:
2924 The expression <literal>s (t xs)</literal> does not match the rule <literal>"map/map"</literal>, but GHC
2925 will substitute for <VarName>s</VarName> and <VarName>t</VarName>, giving an expression which does match.
2926 If <VarName>s</VarName> or <VarName>t</VarName> was (a) used more than once, and (b) large or a redex, then it would
2927 not be substituted, and the rule would not fire.
2934 In the earlier phases of compilation, GHC inlines <emphasis>nothing
2935 that appears on the LHS of a rule</emphasis>, because once you have substituted
2936 for something you can't match against it (given the simple minded
2937 matching). So if you write the rule
2940 "map/map" forall f,g. map f . map g = map (f.g)
2943 this <emphasis>won't</emphasis> match the expression <literal>map f (map g xs)</literal>.
2944 It will only match something written with explicit use of ".".
2945 Well, not quite. It <emphasis>will</emphasis> match the expression
2951 where <function>wibble</function> is defined:
2954 wibble f g = map f . map g
2957 because <function>wibble</function> will be inlined (it's small).
2959 Later on in compilation, GHC starts inlining even things on the
2960 LHS of rules, but still leaves the rules enabled. This inlining
2961 policy is controlled by the per-simplification-pass flag <option>-finline-phase</option><emphasis>n</emphasis>.
2968 All rules are implicitly exported from the module, and are therefore
2969 in force in any module that imports the module that defined the rule, directly
2970 or indirectly. (That is, if A imports B, which imports C, then C's rules are
2971 in force when compiling A.) The situation is very similar to that for instance
2983 <title>List fusion</title>
2986 The RULES mechanism is used to implement fusion (deforestation) of common list functions.
2987 If a "good consumer" consumes an intermediate list constructed by a "good producer", the
2988 intermediate list should be eliminated entirely.
2992 The following are good producers:
3004 Enumerations of <literal>Int</literal> and <literal>Char</literal> (e.g. <literal>['a'..'z']</literal>).
3010 Explicit lists (e.g. <literal>[True, False]</literal>)
3016 The cons constructor (e.g <literal>3:4:[]</literal>)
3022 <function>++</function>
3028 <function>map</function>
3034 <function>filter</function>
3040 <function>iterate</function>, <function>repeat</function>
3046 <function>zip</function>, <function>zipWith</function>
3055 The following are good consumers:
3067 <function>array</function> (on its second argument)
3073 <function>length</function>
3079 <function>++</function> (on its first argument)
3085 <function>map</function>
3091 <function>filter</function>
3097 <function>concat</function>
3103 <function>unzip</function>, <function>unzip2</function>, <function>unzip3</function>, <function>unzip4</function>
3109 <function>zip</function>, <function>zipWith</function> (but on one argument only; if both are good producers, <function>zip</function>
3110 will fuse with one but not the other)
3116 <function>partition</function>
3122 <function>head</function>
3128 <function>and</function>, <function>or</function>, <function>any</function>, <function>all</function>
3134 <function>sequence_</function>
3140 <function>msum</function>
3146 <function>sortBy</function>
3155 So, for example, the following should generate no intermediate lists:
3158 array (1,10) [(i,i*i) | i <- map (+ 1) [0..9]]
3164 This list could readily be extended; if there are Prelude functions that you use
3165 a lot which are not included, please tell us.
3169 If you want to write your own good consumers or producers, look at the
3170 Prelude definitions of the above functions to see how to do so.
3175 <sect2 id="rule-spec">
3176 <title>Specialisation
3180 Rewrite rules can be used to get the same effect as a feature
3181 present in earlier version of GHC:
3184 {-# SPECIALIZE fromIntegral :: Int8 -> Int16 = int8ToInt16 #-}
3187 This told GHC to use <function>int8ToInt16</function> instead of <function>fromIntegral</function> whenever
3188 the latter was called with type <literal>Int8 -> Int16</literal>. That is, rather than
3189 specialising the original definition of <function>fromIntegral</function> the programmer is
3190 promising that it is safe to use <function>int8ToInt16</function> instead.
3194 This feature is no longer in GHC. But rewrite rules let you do the
3199 "fromIntegral/Int8/Int16" fromIntegral = int8ToInt16
3203 This slightly odd-looking rule instructs GHC to replace <function>fromIntegral</function>
3204 by <function>int8ToInt16</function> <emphasis>whenever the types match</emphasis>. Speaking more operationally,
3205 GHC adds the type and dictionary applications to get the typed rule
3208 forall (d1::Integral Int8) (d2::Num Int16) .
3209 fromIntegral Int8 Int16 d1 d2 = int8ToInt16
3213 this rule does not need to be in the same file as fromIntegral,
3214 unlike the <literal>SPECIALISE</literal> pragmas which currently do (so that they
3215 have an original definition available to specialise).
3221 <title>Controlling what's going on</title>
3229 Use <option>-ddump-rules</option> to see what transformation rules GHC is using.
3235 Use <option>-ddump-simpl-stats</option> to see what rules are being fired.
3236 If you add <option>-dppr-debug</option> you get a more detailed listing.
3242 The defintion of (say) <function>build</function> in <FileName>PrelBase.lhs</FileName> looks llike this:
3245 build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
3246 {-# INLINE build #-}
3250 Notice the <literal>INLINE</literal>! That prevents <literal>(:)</literal> from being inlined when compiling
3251 <literal>PrelBase</literal>, so that an importing module will “see” the <literal>(:)</literal>, and can
3252 match it on the LHS of a rule. <literal>INLINE</literal> prevents any inlining happening
3253 in the RHS of the <literal>INLINE</literal> thing. I regret the delicacy of this.
3260 In <filename>ghc/lib/std/PrelBase.lhs</filename> look at the rules for <function>map</function> to
3261 see how to write rules that will do fusion and yet give an efficient
3262 program even if fusion doesn't happen. More rules in <filename>PrelList.lhs</filename>.
3274 <sect1 id="generic-classes">
3275 <title>Generic classes</title>
3278 The ideas behind this extension are described in detail in "Derivable type classes",
3279 Ralf Hinze and Simon Peyton Jones, Haskell Workshop, Montreal Sept 2000, pp94-105.
3280 An example will give the idea:
3288 fromBin :: [Int] -> (a, [Int])
3290 toBin {| Unit |} Unit = []
3291 toBin {| a :+: b |} (Inl x) = 0 : toBin x
3292 toBin {| a :+: b |} (Inr y) = 1 : toBin y
3293 toBin {| a :*: b |} (x :*: y) = toBin x ++ toBin y
3295 fromBin {| Unit |} bs = (Unit, bs)
3296 fromBin {| a :+: b |} (0:bs) = (Inl x, bs') where (x,bs') = fromBin bs
3297 fromBin {| a :+: b |} (1:bs) = (Inr y, bs') where (y,bs') = fromBin bs
3298 fromBin {| a :*: b |} bs = (x :*: y, bs'') where (x,bs' ) = fromBin bs
3299 (y,bs'') = fromBin bs'
3302 This class declaration explains how <literal>toBin</literal> and <literal>fromBin</literal>
3303 work for arbitrary data types. They do so by giving cases for unit, product, and sum,
3304 which are defined thus in the library module <literal>Generics</literal>:
3308 data a :+: b = Inl a | Inr b
3309 data a :*: b = a :*: b
3312 Now you can make a data type into an instance of Bin like this:
3314 instance (Bin a, Bin b) => Bin (a,b)
3315 instance Bin a => Bin [a]
3317 That is, just leave off the "where" clasuse. Of course, you can put in the
3318 where clause and over-ride whichever methods you please.
3322 <title> Using generics </title>
3323 <para>To use generics you need to</para>
3326 <para>Use the flags <option>-fglasgow-exts</option> (to enable the extra syntax),
3327 <option>-fgenerics</option> (to generate extra per-data-type code),
3328 and <option>-package lang</option> (to make the <literal>Generics</literal> library
3332 <para>Import the module <literal>Generics</literal> from the
3333 <literal>lang</literal> package. This import brings into
3334 scope the data types <literal>Unit</literal>,
3335 <literal>:*:</literal>, and <literal>:+:</literal>. (You
3336 don't need this import if you don't mention these types
3337 explicitly; for example, if you are simply giving instance
3338 declarations.)</para>
3343 <sect2> <title> Changes wrt the paper </title>
3345 Note that the type constructors <literal>:+:</literal> and <literal>:*:</literal>
3346 can be written infix (indeed, you can now use
3347 any operator starting in a colon as an infix type constructor). Also note that
3348 the type constructors are not exactly as in the paper (Unit instead of 1, etc).
3349 Finally, note that the syntax of the type patterns in the class declaration
3350 uses "<literal>{|</literal>" and "<literal>|}</literal>" brackets; curly braces
3351 alone would ambiguous when they appear on right hand sides (an extension we
3352 anticipate wanting).
3356 <sect2> <title>Terminology and restrictions</title>
3358 Terminology. A "generic default method" in a class declaration
3359 is one that is defined using type patterns as above.
3360 A "polymorphic default method" is a default method defined as in Haskell 98.
3361 A "generic class declaration" is a class declaration with at least one
3362 generic default method.
3370 Alas, we do not yet implement the stuff about constructor names and
3377 A generic class can have only one parameter; you can't have a generic
3378 multi-parameter class.
3384 A default method must be defined entirely using type patterns, or entirely
3385 without. So this is illegal:
3388 op :: a -> (a, Bool)
3389 op {| Unit |} Unit = (Unit, True)
3392 However it is perfectly OK for some methods of a generic class to have
3393 generic default methods and others to have polymorphic default methods.
3399 The type variable(s) in the type pattern for a generic method declaration
3400 scope over the right hand side. So this is legal (note the use of the type variable ``p'' in a type signature on the right hand side:
3404 op {| p :*: q |} (x :*: y) = op (x :: p)
3412 The type patterns in a generic default method must take one of the forms:
3418 where "a" and "b" are type variables. Furthermore, all the type patterns for
3419 a single type constructor (<literal>:*:</literal>, say) must be identical; they
3420 must use the same type variables. So this is illegal:
3424 op {| a :+: b |} (Inl x) = True
3425 op {| p :+: q |} (Inr y) = False
3427 The type patterns must be identical, even in equations for different methods of the class.
3428 So this too is illegal:
3432 op {| a :*: b |} (Inl x) = True
3435 op {| p :*: q |} (Inr y) = False
3437 (The reason for this restriction is that we gather all the equations for a particular type consructor
3438 into a single generic instance declaration.)
3444 A generic method declaration must give a case for each of the three type constructors.
3450 The type for a generic method can be built only from:
3452 <listitem> <para> Function arrows </para> </listitem>
3453 <listitem> <para> Type variables </para> </listitem>
3454 <listitem> <para> Tuples </para> </listitem>
3455 <listitem> <para> Arbitrary types not involving type variables </para> </listitem>
3457 Here are some example type signatures for generic methods:
3460 op2 :: Bool -> (a,Bool)
3461 op3 :: [Int] -> a -> a
3464 Here, op1, op2, op3 are OK, but op4 is rejected, because it has a type variable
3468 This restriction is an implementation restriction: we just havn't got around to
3469 implementing the necessary bidirectional maps over arbitrary type constructors.
3470 It would be relatively easy to add specific type constructors, such as Maybe and list,
3471 to the ones that are allowed.</para>
3476 In an instance declaration for a generic class, the idea is that the compiler
3477 will fill in the methods for you, based on the generic templates. However it can only
3482 The instance type is simple (a type constructor applied to type variables, as in Haskell 98).
3487 No constructor of the instance type has unboxed fields.
3491 (Of course, these things can only arise if you are already using GHC extensions.)
3492 However, you can still give an instance declarations for types which break these rules,
3493 provided you give explicit code to override any generic default methods.
3501 The option <option>-ddump-deriv</option> dumps incomprehensible stuff giving details of
3502 what the compiler does with generic declarations.
3507 <sect2> <title> Another example </title>
3509 Just to finish with, here's another example I rather like:
3513 nCons {| Unit |} _ = 1
3514 nCons {| a :*: b |} _ = 1
3515 nCons {| a :+: b |} _ = nCons (bot::a) + nCons (bot::b)
3518 tag {| Unit |} _ = 1
3519 tag {| a :*: b |} _ = 1
3520 tag {| a :+: b |} (Inl x) = tag x
3521 tag {| a :+: b |} (Inr y) = nCons (bot::a) + tag y
3528 ;;; Local Variables: ***
3530 ;;; sgml-parent-document: ("users_guide.sgml" "book" "chapter" "sect1") ***
projects / ghc-hetmet.git / blob