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">).
604 You must use the <option>-fglasgow-exts</option> command-line option
605 to make GHC understand the <literal>foreign</literal> declarations
606 defined by the FFI.</para>
610 <para>The <literal>Foreign</literal> module (see <xref
611 linkend="sec-Foreign">) collects together several interfaces
612 which are useful in specifying foreign language
613 interfaces, including the following:</para>
617 <para>The <literal>ForeignObj</literal> module (see <xref
618 linkend="sec-ForeignObj">), for managing pointers from
619 Haskell into the outside world.</para>
623 <para>The <literal>StablePtr</literal> module (see <xref
624 linkend="sec-stable-pointers">), for managing pointers
625 into Haskell from the outside world.</para>
629 <para>The <literal>CTypes</literal> module (see <xref
630 linkend="sec-CTypes">) gives Haskell equivalents for the
631 standard C datatypes, for use in making Haskell bindings
632 to existing C libraries.</para>
636 <para>The <literal>CTypesISO</literal> module (see <xref
637 linkend="sec-CTypesISO">) gives Haskell equivalents for C
638 types defined by the ISO C standard.</para>
642 <para>The <literal>Storable</literal> library, for
643 primitive marshalling of data types between Haskell and
644 the foreign language.</para>
651 <para>The following sections also give some hints and tips on the use
652 of the foreign function interface in GHC.</para>
654 <sect2 id="glasgow-foreign-headers">
655 <title>Using function headers
659 <indexterm><primary>C calls, function headers</primary></indexterm>
663 When generating C (using the <option>-fvia-C</option> directive), one can assist the
664 C compiler in detecting type errors by using the <option>-#include</option> directive
665 (<xref linkend="options-C-compiler">) to provide <filename>.h</filename> files containing function headers.
677 void initialiseEFS (HsInt size);
678 HsInt terminateEFS (void);
679 HsForeignObj emptyEFS(void);
680 HsForeignObj updateEFS (HsForeignObj a, HsInt i, HsInt x);
681 HsInt lookupEFS (HsForeignObj a, HsInt i);
685 <para>The types <literal>HsInt</literal>,
686 <literal>HsForeignObj</literal> etc. are described in <xref
687 linkend="sec-mapping-table">.</para>
689 <para>Note that this approach is only
690 <emphasis>essential</emphasis> for returning
691 <literal>float</literal>s (or if <literal>sizeof(int) !=
692 sizeof(int *)</literal> on your architecture) but is a Good
693 Thing for anyone who cares about writing solid code. You're
694 crazy not to do it.</para>
700 <sect1 id="multi-param-type-classes">
701 <title>Multi-parameter type classes
705 This section documents GHC's implementation of multi-parameter type
706 classes. There's lots of background in the paper <ULink
707 URL="http://research.microsoft.com/~simonpj/multi.ps.gz" >Type
708 classes: exploring the design space</ULink > (Simon Peyton Jones, Mark
713 I'd like to thank people who reported shorcomings in the GHC 3.02
714 implementation. Our default decisions were all conservative ones, and
715 the experience of these heroic pioneers has given useful concrete
716 examples to support several generalisations. (These appear below as
717 design choices not implemented in 3.02.)
721 I've discussed these notes with Mark Jones, and I believe that Hugs
722 will migrate towards the same design choices as I outline here.
723 Thanks to him, and to many others who have offered very useful
731 There are the following restrictions on the form of a qualified
738 forall tv1..tvn (c1, ...,cn) => type
744 (Here, I write the "foralls" explicitly, although the Haskell source
745 language omits them; in Haskell 1.4, all the free type variables of an
746 explicit source-language type signature are universally quantified,
747 except for the class type variables in a class declaration. However,
748 in GHC, you can give the foralls if you want. See <xref LinkEnd="universal-quantification">).
757 <emphasis>Each universally quantified type variable
758 <literal>tvi</literal> must be mentioned (i.e. appear free) in <literal>type</literal></emphasis>.
760 The reason for this is that a value with a type that does not obey
761 this restriction could not be used without introducing
762 ambiguity. Here, for example, is an illegal type:
766 forall a. Eq a => Int
770 When a value with this type was used, the constraint <literal>Eq tv</literal>
771 would be introduced where <literal>tv</literal> is a fresh type variable, and
772 (in the dictionary-translation implementation) the value would be
773 applied to a dictionary for <literal>Eq tv</literal>. The difficulty is that we
774 can never know which instance of <literal>Eq</literal> to use because we never
775 get any more information about <literal>tv</literal>.
782 <emphasis>Every constraint <literal>ci</literal> must mention at least one of the
783 universally quantified type variables <literal>tvi</literal></emphasis>.
785 For example, this type is OK because <literal>C a b</literal> mentions the
786 universally quantified type variable <literal>b</literal>:
790 forall a. C a b => burble
794 The next type is illegal because the constraint <literal>Eq b</literal> does not
795 mention <literal>a</literal>:
799 forall a. Eq b => burble
803 The reason for this restriction is milder than the other one. The
804 excluded types are never useful or necessary (because the offending
805 context doesn't need to be witnessed at this point; it can be floated
806 out). Furthermore, floating them out increases sharing. Lastly,
807 excluding them is a conservative choice; it leaves a patch of
808 territory free in case we need it later.
818 These restrictions apply to all types, whether declared in a type signature
823 Unlike Haskell 1.4, constraints in types do <emphasis>not</emphasis> have to be of
824 the form <emphasis>(class type-variables)</emphasis>. Thus, these type signatures
831 f :: Eq (m a) => [m a] -> [m a]
838 This choice recovers principal types, a property that Haskell 1.4 does not have.
844 <title>Class declarations</title>
852 <emphasis>Multi-parameter type classes are permitted</emphasis>. For example:
856 class Collection c a where
857 union :: c a -> c a -> c a
868 <emphasis>The class hierarchy must be acyclic</emphasis>. However, the definition
869 of "acyclic" involves only the superclass relationships. For example,
875 op :: D b => a -> b -> b
878 class C a => D a where { ... }
882 Here, <literal>C</literal> is a superclass of <literal>D</literal>, but it's OK for a
883 class operation <literal>op</literal> of <literal>C</literal> to mention <literal>D</literal>. (It
884 would not be OK for <literal>D</literal> to be a superclass of <literal>C</literal>.)
891 <emphasis>There are no restrictions on the context in a class declaration
892 (which introduces superclasses), except that the class hierarchy must
893 be acyclic</emphasis>. So these class declarations are OK:
897 class Functor (m k) => FiniteMap m k where
900 class (Monad m, Monad (t m)) => Transform t m where
901 lift :: m a -> (t m) a
910 <emphasis>In the signature of a class operation, every constraint
911 must mention at least one type variable that is not a class type
918 class Collection c a where
919 mapC :: Collection c b => (a->b) -> c a -> c b
923 is OK because the constraint <literal>(Collection a b)</literal> mentions
924 <literal>b</literal>, even though it also mentions the class variable
925 <literal>a</literal>. On the other hand:
930 op :: Eq a => (a,b) -> (a,b)
934 is not OK because the constraint <literal>(Eq a)</literal> mentions on the class
935 type variable <literal>a</literal>, but not <literal>b</literal>. However, any such
936 example is easily fixed by moving the offending context up to the
941 class Eq a => C a where
946 A yet more relaxed rule would allow the context of a class-op signature
947 to mention only class type variables. However, that conflicts with
948 Rule 1(b) for types above.
955 <emphasis>The type of each class operation must mention <emphasis>all</emphasis> of
956 the class type variables</emphasis>. For example:
962 insert :: s -> a -> s
966 is not OK, because the type of <literal>empty</literal> doesn't mention
967 <literal>a</literal>. This rule is a consequence of Rule 1(a), above, for
968 types, and has the same motivation.
970 Sometimes, offending class declarations exhibit misunderstandings. For
971 example, <literal>Coll</literal> might be rewritten
977 insert :: s a -> a -> s a
981 which makes the connection between the type of a collection of
982 <literal>a</literal>'s (namely <literal>(s a)</literal>) and the element type <literal>a</literal>.
983 Occasionally this really doesn't work, in which case you can split the
991 class CollE s => Coll s a where
992 insert :: s -> a -> s
1005 <sect2 id="instance-decls">
1006 <title>Instance declarations</title>
1014 <emphasis>Instance declarations may not overlap</emphasis>. The two instance
1019 instance context1 => C type1 where ...
1020 instance context2 => C type2 where ...
1024 "overlap" if <literal>type1</literal> and <literal>type2</literal> unify
1026 However, if you give the command line option
1027 <option>-fallow-overlapping-instances</option><indexterm><primary>-fallow-overlapping-instances
1028 option</primary></indexterm> then two overlapping instance declarations are permitted
1036 EITHER <literal>type1</literal> and <literal>type2</literal> do not unify
1042 OR <literal>type2</literal> is a substitution instance of <literal>type1</literal>
1043 (but not identical to <literal>type1</literal>)
1056 Notice that these rules
1063 make it clear which instance decl to use
1064 (pick the most specific one that matches)
1071 do not mention the contexts <literal>context1</literal>, <literal>context2</literal>
1072 Reason: you can pick which instance decl
1073 "matches" based on the type.
1080 Regrettably, GHC doesn't guarantee to detect overlapping instance
1081 declarations if they appear in different modules. GHC can "see" the
1082 instance declarations in the transitive closure of all the modules
1083 imported by the one being compiled, so it can "see" all instance decls
1084 when it is compiling <literal>Main</literal>. However, it currently chooses not
1085 to look at ones that can't possibly be of use in the module currently
1086 being compiled, in the interests of efficiency. (Perhaps we should
1087 change that decision, at least for <literal>Main</literal>.)
1094 <emphasis>There are no restrictions on the type in an instance
1095 <emphasis>head</emphasis>, except that at least one must not be a type variable</emphasis>.
1096 The instance "head" is the bit after the "=>" in an instance decl. For
1097 example, these are OK:
1101 instance C Int a where ...
1103 instance D (Int, Int) where ...
1105 instance E [[a]] where ...
1109 Note that instance heads <emphasis>may</emphasis> contain repeated type variables.
1110 For example, this is OK:
1114 instance Stateful (ST s) (MutVar s) where ...
1118 The "at least one not a type variable" restriction is to ensure that
1119 context reduction terminates: each reduction step removes one type
1120 constructor. For example, the following would make the type checker
1121 loop if it wasn't excluded:
1125 instance C a => C a where ...
1129 There are two situations in which the rule is a bit of a pain. First,
1130 if one allows overlapping instance declarations then it's quite
1131 convenient to have a "default instance" declaration that applies if
1132 something more specific does not:
1141 Second, sometimes you might want to use the following to get the
1142 effect of a "class synonym":
1146 class (C1 a, C2 a, C3 a) => C a where { }
1148 instance (C1 a, C2 a, C3 a) => C a where { }
1152 This allows you to write shorter signatures:
1164 f :: (C1 a, C2 a, C3 a) => ...
1168 I'm on the lookout for a simple rule that preserves decidability while
1169 allowing these idioms. The experimental flag
1170 <option>-fallow-undecidable-instances</option><indexterm><primary>-fallow-undecidable-instances
1171 option</primary></indexterm> lifts this restriction, allowing all the types in an
1172 instance head to be type variables.
1179 <emphasis>Unlike Haskell 1.4, instance heads may use type
1180 synonyms</emphasis>. As always, using a type synonym is just shorthand for
1181 writing the RHS of the type synonym definition. For example:
1185 type Point = (Int,Int)
1186 instance C Point where ...
1187 instance C [Point] where ...
1191 is legal. However, if you added
1195 instance C (Int,Int) where ...
1199 as well, then the compiler will complain about the overlapping
1200 (actually, identical) instance declarations. As always, type synonyms
1201 must be fully applied. You cannot, for example, write:
1206 instance Monad P where ...
1210 This design decision is independent of all the others, and easily
1211 reversed, but it makes sense to me.
1218 <emphasis>The types in an instance-declaration <emphasis>context</emphasis> must all
1219 be type variables</emphasis>. Thus
1223 instance C a b => Eq (a,b) where ...
1231 instance C Int b => Foo b where ...
1235 is not OK. Again, the intent here is to make sure that context
1236 reduction terminates.
1238 Voluminous correspondence on the Haskell mailing list has convinced me
1239 that it's worth experimenting with a more liberal rule. If you use
1240 the flag <option>-fallow-undecidable-instances</option> can use arbitrary
1241 types in an instance context. Termination is ensured by having a
1242 fixed-depth recursion stack. If you exceed the stack depth you get a
1243 sort of backtrace, and the opportunity to increase the stack depth
1244 with <option>-fcontext-stack</option><emphasis>N</emphasis>.
1257 <sect1 id="implicit-parameters">
1258 <title>Implicit parameters
1261 <para> Implicit paramters are implemented as described in
1262 "Implicit parameters: dynamic scoping with static types",
1263 J Lewis, MB Shields, E Meijer, J Launchbury,
1264 27th ACM Symposium on Principles of Programming Languages (POPL'00),
1269 There should be more documentation, but there isn't (yet). Yell if you need it.
1273 <para> You can't have an implicit parameter in the context of a class or instance
1274 declaration. For example, both these declarations are illegal:
1276 class (?x::Int) => C a where ...
1277 instance (?x::a) => Foo [a] where ...
1279 Reason: exactly which implicit parameter you pick up depends on exactly where
1280 you invoke a function. But the ``invocation'' of instance declarations is done
1281 behind the scenes by the compiler, so it's hard to figure out exactly where it is done.
1282 Easiest thing is to outlaw the offending types.</para>
1290 <sect1 id="functional-dependencies">
1291 <title>Functional dependencies
1294 <para> Functional dependencies are implemented as described by Mark Jones
1295 in "Type Classes with Functional Dependencies", Mark P. Jones,
1296 In Proceedings of the 9th European Symposium on Programming,
1297 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782.
1301 There should be more documentation, but there isn't (yet). Yell if you need it.
1306 <sect1 id="universal-quantification">
1307 <title>Explicit universal quantification
1311 GHC's type system supports explicit universal quantification in
1312 constructor fields and function arguments. This is useful for things
1313 like defining <literal>runST</literal> from the state-thread world.
1314 GHC's syntax for this now agrees with Hugs's, namely:
1320 forall a b. (Ord a, Eq b) => a -> b -> a
1326 The context is, of course, optional. You can't use <literal>forall</literal> as
1327 a type variable any more!
1331 Haskell type signatures are implicitly quantified. The <literal>forall</literal>
1332 allows us to say exactly what this means. For example:
1350 g :: forall b. (b -> b)
1356 The two are treated identically.
1360 <title>Universally-quantified data type fields
1364 In a <literal>data</literal> or <literal>newtype</literal> declaration one can quantify
1365 the types of the constructor arguments. Here are several examples:
1371 data T a = T1 (forall b. b -> b -> b) a
1373 data MonadT m = MkMonad { return :: forall a. a -> m a,
1374 bind :: forall a b. m a -> (a -> m b) -> m b
1377 newtype Swizzle = MkSwizzle (Ord a => [a] -> [a])
1383 The constructors now have so-called <emphasis>rank 2</emphasis> polymorphic
1384 types, in which there is a for-all in the argument types.:
1390 T1 :: forall a. (forall b. b -> b -> b) -> a -> T a
1391 MkMonad :: forall m. (forall a. a -> m a)
1392 -> (forall a b. m a -> (a -> m b) -> m b)
1394 MkSwizzle :: (Ord a => [a] -> [a]) -> Swizzle
1400 Notice that you don't need to use a <literal>forall</literal> if there's an
1401 explicit context. For example in the first argument of the
1402 constructor <function>MkSwizzle</function>, an implicit "<literal>forall a.</literal>" is
1403 prefixed to the argument type. The implicit <literal>forall</literal>
1404 quantifies all type variables that are not already in scope, and are
1405 mentioned in the type quantified over.
1409 As for type signatures, implicit quantification happens for non-overloaded
1410 types too. So if you write this:
1413 data T a = MkT (Either a b) (b -> b)
1416 it's just as if you had written this:
1419 data T a = MkT (forall b. Either a b) (forall b. b -> b)
1422 That is, since the type variable <literal>b</literal> isn't in scope, it's
1423 implicitly universally quantified. (Arguably, it would be better
1424 to <emphasis>require</emphasis> explicit quantification on constructor arguments
1425 where that is what is wanted. Feedback welcomed.)
1431 <title>Construction </title>
1434 You construct values of types <literal>T1, MonadT, Swizzle</literal> by applying
1435 the constructor to suitable values, just as usual. For example,
1441 (T1 (\xy->x) 3) :: T Int
1443 (MkSwizzle sort) :: Swizzle
1444 (MkSwizzle reverse) :: Swizzle
1451 MkMonad r b) :: MonadT Maybe
1457 The type of the argument can, as usual, be more general than the type
1458 required, as <literal>(MkSwizzle reverse)</literal> shows. (<function>reverse</function>
1459 does not need the <literal>Ord</literal> constraint.)
1465 <title>Pattern matching</title>
1468 When you use pattern matching, the bound variables may now have
1469 polymorphic types. For example:
1475 f :: T a -> a -> (a, Char)
1476 f (T1 f k) x = (f k x, f 'c' 'd')
1478 g :: (Ord a, Ord b) => Swizzle -> [a] -> (a -> b) -> [b]
1479 g (MkSwizzle s) xs f = s (map f (s xs))
1481 h :: MonadT m -> [m a] -> m [a]
1482 h m [] = return m []
1483 h m (x:xs) = bind m x $ \y ->
1484 bind m (h m xs) $ \ys ->
1491 In the function <function>h</function> we use the record selectors <literal>return</literal>
1492 and <literal>bind</literal> to extract the polymorphic bind and return functions
1493 from the <literal>MonadT</literal> data structure, rather than using pattern
1498 You cannot pattern-match against an argument that is polymorphic.
1502 newtype TIM s a = TIM (ST s (Maybe a))
1504 runTIM :: (forall s. TIM s a) -> Maybe a
1505 runTIM (TIM m) = runST m
1511 Here the pattern-match fails, because you can't pattern-match against
1512 an argument of type <literal>(forall s. TIM s a)</literal>. Instead you
1513 must bind the variable and pattern match in the right hand side:
1516 runTIM :: (forall s. TIM s a) -> Maybe a
1517 runTIM tm = case tm of { TIM m -> runST m }
1520 The <literal>tm</literal> on the right hand side is (invisibly) instantiated, like
1521 any polymorphic value at its occurrence site, and now you can pattern-match
1528 <title>The partial-application restriction</title>
1531 There is really only one way in which data structures with polymorphic
1532 components might surprise you: you must not partially apply them.
1533 For example, this is illegal:
1539 map MkSwizzle [sort, reverse]
1545 The restriction is this: <emphasis>every subexpression of the program must
1546 have a type that has no for-alls, except that in a function
1547 application (f e1…en) the partial applications are not subject to
1548 this rule</emphasis>. The restriction makes type inference feasible.
1552 In the illegal example, the sub-expression <literal>MkSwizzle</literal> has the
1553 polymorphic type <literal>(Ord b => [b] -> [b]) -> Swizzle</literal> and is not
1554 a sub-expression of an enclosing application. On the other hand, this
1561 map (T1 (\a b -> a)) [1,2,3]
1567 even though it involves a partial application of <function>T1</function>, because
1568 the sub-expression <literal>T1 (\a b -> a)</literal> has type <literal>Int -> T
1575 <title>Type signatures
1579 Once you have data constructors with universally-quantified fields, or
1580 constants such as <Constant>runST</Constant> that have rank-2 types, it isn't long
1581 before you discover that you need more! Consider:
1587 mkTs f x y = [T1 f x, T1 f y]
1593 <function>mkTs</function> is a fuction that constructs some values of type
1594 <literal>T</literal>, using some pieces passed to it. The trouble is that since
1595 <literal>f</literal> is a function argument, Haskell assumes that it is
1596 monomorphic, so we'll get a type error when applying <function>T1</function> to
1597 it. This is a rather silly example, but the problem really bites in
1598 practice. Lots of people trip over the fact that you can't make
1599 "wrappers functions" for <Constant>runST</Constant> for exactly the same reason.
1600 In short, it is impossible to build abstractions around functions with
1605 The solution is fairly clear. We provide the ability to give a rank-2
1606 type signature for <emphasis>ordinary</emphasis> functions (not only data
1607 constructors), thus:
1613 mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1614 mkTs f x y = [T1 f x, T1 f y]
1620 This type signature tells the compiler to attribute <literal>f</literal> with
1621 the polymorphic type <literal>(forall b. b -> b -> b)</literal> when type
1622 checking the body of <function>mkTs</function>, so now the application of
1623 <function>T1</function> is fine.
1627 There are two restrictions:
1636 You can only define a rank 2 type, specified by the following
1641 rank2type ::= [forall tyvars .] [context =>] funty
1642 funty ::= ([forall tyvars .] [context =>] ty) -> funty
1644 ty ::= ...current Haskell monotype syntax...
1648 Informally, the universal quantification must all be right at the beginning,
1649 or at the top level of a function argument.
1656 There is a restriction on the definition of a function whose
1657 type signature is a rank-2 type: the polymorphic arguments must be
1658 matched on the left hand side of the "<literal>=</literal>" sign. You can't
1659 define <function>mkTs</function> like this:
1663 mkTs :: (forall b. b -> b -> b) -> a -> [T a]
1664 mkTs = \ f x y -> [T1 f x, T1 f y]
1669 The same partial-application rule applies to ordinary functions with
1670 rank-2 types as applied to data constructors.
1683 <title>Type synonyms and hoisting
1687 GHC also allows you to write a <literal>forall</literal> in a type synonym, thus:
1689 type Discard a = forall b. a -> b -> a
1694 However, it is often convenient to use these sort of synonyms at the right hand
1695 end of an arrow, thus:
1697 type Discard a = forall b. a -> b -> a
1699 g :: Int -> Discard Int
1702 Simply expanding the type synonym would give
1704 g :: Int -> (forall b. Int -> b -> Int)
1706 but GHC "hoists" the <literal>forall</literal> to give the isomorphic type
1708 g :: forall b. Int -> Int -> b -> Int
1710 In general, the rule is this: <emphasis>to determine the type specified by any explicit
1711 user-written type (e.g. in a type signature), GHC expands type synonyms and then repeatedly
1712 performs the transformation:</emphasis>
1714 <emphasis>type1</emphasis> -> forall a. <emphasis>type2</emphasis>
1716 forall a. <emphasis>type1</emphasis> -> <emphasis>type2</emphasis>
1718 (In fact, GHC tries to retain as much synonym information as possible for use in
1719 error messages, but that is a usability issue.) This rule applies, of course, whether
1720 or not the <literal>forall</literal> comes from a synonym. For example, here is another
1721 valid way to write <literal>g</literal>'s type signature:
1723 g :: Int -> Int -> forall b. b -> Int
1730 <sect1 id="existential-quantification">
1731 <title>Existentially quantified data constructors
1735 The idea of using existential quantification in data type declarations
1736 was suggested by Laufer (I believe, thought doubtless someone will
1737 correct me), and implemented in Hope+. It's been in Lennart
1738 Augustsson's <Command>hbc</Command> Haskell compiler for several years, and
1739 proved very useful. Here's the idea. Consider the declaration:
1745 data Foo = forall a. MkFoo a (a -> Bool)
1752 The data type <literal>Foo</literal> has two constructors with types:
1758 MkFoo :: forall a. a -> (a -> Bool) -> Foo
1765 Notice that the type variable <literal>a</literal> in the type of <function>MkFoo</function>
1766 does not appear in the data type itself, which is plain <literal>Foo</literal>.
1767 For example, the following expression is fine:
1773 [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
1779 Here, <literal>(MkFoo 3 even)</literal> packages an integer with a function
1780 <function>even</function> that maps an integer to <literal>Bool</literal>; and <function>MkFoo 'c'
1781 isUpper</function> packages a character with a compatible function. These
1782 two things are each of type <literal>Foo</literal> and can be put in a list.
1786 What can we do with a value of type <literal>Foo</literal>?. In particular,
1787 what happens when we pattern-match on <function>MkFoo</function>?
1793 f (MkFoo val fn) = ???
1799 Since all we know about <literal>val</literal> and <function>fn</function> is that they
1800 are compatible, the only (useful) thing we can do with them is to
1801 apply <function>fn</function> to <literal>val</literal> to get a boolean. For example:
1808 f (MkFoo val fn) = fn val
1814 What this allows us to do is to package heterogenous values
1815 together with a bunch of functions that manipulate them, and then treat
1816 that collection of packages in a uniform manner. You can express
1817 quite a bit of object-oriented-like programming this way.
1820 <sect2 id="existential">
1821 <title>Why existential?
1825 What has this to do with <emphasis>existential</emphasis> quantification?
1826 Simply that <function>MkFoo</function> has the (nearly) isomorphic type
1832 MkFoo :: (exists a . (a, a -> Bool)) -> Foo
1838 But Haskell programmers can safely think of the ordinary
1839 <emphasis>universally</emphasis> quantified type given above, thereby avoiding
1840 adding a new existential quantification construct.
1846 <title>Type classes</title>
1849 An easy extension (implemented in <Command>hbc</Command>) is to allow
1850 arbitrary contexts before the constructor. For example:
1856 data Baz = forall a. Eq a => Baz1 a a
1857 | forall b. Show b => Baz2 b (b -> b)
1863 The two constructors have the types you'd expect:
1869 Baz1 :: forall a. Eq a => a -> a -> Baz
1870 Baz2 :: forall b. Show b => b -> (b -> b) -> Baz
1876 But when pattern matching on <function>Baz1</function> the matched values can be compared
1877 for equality, and when pattern matching on <function>Baz2</function> the first matched
1878 value can be converted to a string (as well as applying the function to it).
1879 So this program is legal:
1886 f (Baz1 p q) | p == q = "Yes"
1888 f (Baz1 v fn) = show (fn v)
1894 Operationally, in a dictionary-passing implementation, the
1895 constructors <function>Baz1</function> and <function>Baz2</function> must store the
1896 dictionaries for <literal>Eq</literal> and <literal>Show</literal> respectively, and
1897 extract it on pattern matching.
1901 Notice the way that the syntax fits smoothly with that used for
1902 universal quantification earlier.
1908 <title>Restrictions</title>
1911 There are several restrictions on the ways in which existentially-quantified
1912 constructors can be use.
1921 When pattern matching, each pattern match introduces a new,
1922 distinct, type for each existential type variable. These types cannot
1923 be unified with any other type, nor can they escape from the scope of
1924 the pattern match. For example, these fragments are incorrect:
1932 Here, the type bound by <function>MkFoo</function> "escapes", because <literal>a</literal>
1933 is the result of <function>f1</function>. One way to see why this is wrong is to
1934 ask what type <function>f1</function> has:
1938 f1 :: Foo -> a -- Weird!
1942 What is this "<literal>a</literal>" in the result type? Clearly we don't mean
1947 f1 :: forall a. Foo -> a -- Wrong!
1951 The original program is just plain wrong. Here's another sort of error
1955 f2 (Baz1 a b) (Baz1 p q) = a==q
1959 It's ok to say <literal>a==b</literal> or <literal>p==q</literal>, but
1960 <literal>a==q</literal> is wrong because it equates the two distinct types arising
1961 from the two <function>Baz1</function> constructors.
1969 You can't pattern-match on an existentially quantified
1970 constructor in a <literal>let</literal> or <literal>where</literal> group of
1971 bindings. So this is illegal:
1975 f3 x = a==b where { Baz1 a b = x }
1979 You can only pattern-match
1980 on an existentially-quantified constructor in a <literal>case</literal> expression or
1981 in the patterns of a function definition.
1983 The reason for this restriction is really an implementation one.
1984 Type-checking binding groups is already a nightmare without
1985 existentials complicating the picture. Also an existential pattern
1986 binding at the top level of a module doesn't make sense, because it's
1987 not clear how to prevent the existentially-quantified type "escaping".
1988 So for now, there's a simple-to-state restriction. We'll see how
1996 You can't use existential quantification for <literal>newtype</literal>
1997 declarations. So this is illegal:
2001 newtype T = forall a. Ord a => MkT a
2005 Reason: a value of type <literal>T</literal> must be represented as a pair
2006 of a dictionary for <literal>Ord t</literal> and a value of type <literal>t</literal>.
2007 That contradicts the idea that <literal>newtype</literal> should have no
2008 concrete representation. You can get just the same efficiency and effect
2009 by using <literal>data</literal> instead of <literal>newtype</literal>. If there is no
2010 overloading involved, then there is more of a case for allowing
2011 an existentially-quantified <literal>newtype</literal>, because the <literal>data</literal>
2012 because the <literal>data</literal> version does carry an implementation cost,
2013 but single-field existentially quantified constructors aren't much
2014 use. So the simple restriction (no existential stuff on <literal>newtype</literal>)
2015 stands, unless there are convincing reasons to change it.
2023 You can't use <literal>deriving</literal> to define instances of a
2024 data type with existentially quantified data constructors.
2026 Reason: in most cases it would not make sense. For example:#
2029 data T = forall a. MkT [a] deriving( Eq )
2032 To derive <literal>Eq</literal> in the standard way we would need to have equality
2033 between the single component of two <function>MkT</function> constructors:
2037 (MkT a) == (MkT b) = ???
2040 But <VarName>a</VarName> and <VarName>b</VarName> have distinct types, and so can't be compared.
2041 It's just about possible to imagine examples in which the derived instance
2042 would make sense, but it seems altogether simpler simply to prohibit such
2043 declarations. Define your own instances!
2055 <sect1 id="sec-assertions">
2057 <indexterm><primary>Assertions</primary></indexterm>
2061 If you want to make use of assertions in your standard Haskell code, you
2062 could define a function like the following:
2068 assert :: Bool -> a -> a
2069 assert False x = error "assertion failed!"
2076 which works, but gives you back a less than useful error message --
2077 an assertion failed, but which and where?
2081 One way out is to define an extended <function>assert</function> function which also
2082 takes a descriptive string to include in the error message and
2083 perhaps combine this with the use of a pre-processor which inserts
2084 the source location where <function>assert</function> was used.
2088 Ghc offers a helping hand here, doing all of this for you. For every
2089 use of <function>assert</function> in the user's source:
2095 kelvinToC :: Double -> Double
2096 kelvinToC k = assert (k >= 0.0) (k+273.15)
2102 Ghc will rewrite this to also include the source location where the
2109 assert pred val ==> assertError "Main.hs|15" pred val
2115 The rewrite is only performed by the compiler when it spots
2116 applications of <function>Exception.assert</function>, so you can still define and
2117 use your own versions of <function>assert</function>, should you so wish. If not,
2118 import <literal>Exception</literal> to make use <function>assert</function> in your code.
2122 To have the compiler ignore uses of assert, use the compiler option
2123 <option>-fignore-asserts</option>. <indexterm><primary>-fignore-asserts option</primary></indexterm> That is,
2124 expressions of the form <literal>assert pred e</literal> will be rewritten to <literal>e</literal>.
2128 Assertion failures can be caught, see the documentation for the
2129 <literal>Exception</literal> library (<xref linkend="sec-Exception">)
2135 <sect1 id="scoped-type-variables">
2136 <title>Scoped Type Variables
2140 A <emphasis>pattern type signature</emphasis> can introduce a <emphasis>scoped type
2141 variable</emphasis>. For example
2147 f (xs::[a]) = ys ++ ys
2156 The pattern <literal>(xs::[a])</literal> includes a type signature for <VarName>xs</VarName>.
2157 This brings the type variable <literal>a</literal> into scope; it scopes over
2158 all the patterns and right hand sides for this equation for <function>f</function>.
2159 In particular, it is in scope at the type signature for <VarName>y</VarName>.
2163 Pattern type signatures are completely orthogonal to ordinary, separate
2164 type signatures. The two can be used independently or together.
2165 At ordinary type signatures, such as that for <VarName>ys</VarName>, any type variables
2166 mentioned in the type signature <emphasis>that are not in scope</emphasis> are
2167 implicitly universally quantified. (If there are no type variables in
2168 scope, all type variables mentioned in the signature are universally
2169 quantified, which is just as in Haskell 98.) In this case, since <VarName>a</VarName>
2170 is in scope, it is not universally quantified, so the type of <VarName>ys</VarName> is
2171 the same as that of <VarName>xs</VarName>. In Haskell 98 it is not possible to declare
2172 a type for <VarName>ys</VarName>; a major benefit of scoped type variables is that
2173 it becomes possible to do so.
2177 Scoped type variables are implemented in both GHC and Hugs. Where the
2178 implementations differ from the specification below, those differences
2183 So much for the basic idea. Here are the details.
2187 <title>What a pattern type signature means</title>
2189 A type variable brought into scope by a pattern type signature is simply
2190 the name for a type. The restriction they express is that all occurrences
2191 of the same name mean the same type. For example:
2193 f :: [Int] -> Int -> Int
2194 f (xs::[a]) (y::a) = (head xs + y) :: a
2196 The pattern type signatures on the left hand side of
2197 <literal>f</literal> express the fact that <literal>xs</literal>
2198 must be a list of things of some type <literal>a</literal>; and that <literal>y</literal>
2199 must have this same type. The type signature on the expression <literal>(head xs)</literal>
2200 specifies that this expression must have the same type <literal>a</literal>.
2201 <emphasis>There is no requirement that the type named by "<literal>a</literal>" is
2202 in fact a type variable</emphasis>. Indeed, in this case, the type named by "<literal>a</literal>" is
2203 <literal>Int</literal>. (This is a slight liberalisation from the original rather complex
2204 rules, which specified that a pattern-bound type variable should be universally quantified.)
2205 For example, all of these are legal:</para>
2208 t (x::a) (y::a) = x+y*2
2210 f (x::a) (y::b) = [x,y] -- a unifies with b
2212 g (x::a) = x + 1::Int -- a unifies with Int
2214 h x = let k (y::a) = [x,y] -- a is free in the
2215 in k x -- environment
2217 k (x::a) True = ... -- a unifies with Int
2218 k (x::Int) False = ...
2221 w (x::a) = x -- a unifies with [b]
2227 <title>Scope and implicit quantification</title>
2235 All the type variables mentioned in a pattern,
2236 that are not already in scope,
2237 are brought into scope by the pattern. We describe this set as
2238 the <emphasis>type variables bound by the pattern</emphasis>.
2241 f (x::a) = let g (y::(a,b)) = fst y
2245 The pattern <literal>(x::a)</literal> brings the type variable
2246 <literal>a</literal> into scope, as well as the term
2247 variable <literal>x</literal>. The pattern <literal>(y::(a,b))</literal>
2248 contains an occurrence of the already-in-scope type variable <literal>a</literal>,
2249 and brings into scope the type variable <literal>b</literal>.
2255 The type variables thus brought into scope may be mentioned
2256 in ordinary type signatures or pattern type signatures anywhere within
2264 In ordinary type signatures, any type variable mentioned in the
2265 signature that is in scope is <emphasis>not</emphasis> universally quantified.
2273 Ordinary type signatures do not bring any new type variables
2274 into scope (except in the type signature itself!). So this is illegal:
2281 It's illegal because <VarName>a</VarName> is not in scope in the body of <function>f</function>,
2282 so the ordinary signature <literal>x::a</literal> is equivalent to <literal>x::forall a.a</literal>;
2283 and that is an incorrect typing.
2290 There is no implicit universal quantification on pattern type
2291 signatures, nor may one write an explicit <literal>forall</literal> type in a pattern
2292 type signature. The pattern type signature is a monotype.
2300 The type variables in the head of a <literal>class</literal> or <literal>instance</literal> declaration
2301 scope over the methods defined in the <literal>where</literal> part. For example:
2315 (Not implemented in Hugs yet, Dec 98).
2326 <title>Result type signatures</title>
2334 The result type of a function can be given a signature,
2339 f (x::a) :: [a] = [x,x,x]
2343 The final <literal>:: [a]</literal> after all the patterns gives a signature to the
2344 result type. Sometimes this is the only way of naming the type variable
2349 f :: Int -> [a] -> [a]
2350 f n :: ([a] -> [a]) = let g (x::a, y::a) = (y,x)
2351 in \xs -> map g (reverse xs `zip` xs)
2363 Result type signatures are not yet implemented in Hugs.
2369 <title>Where a pattern type signature can occur</title>
2372 A pattern type signature can occur in any pattern, but there
2373 are restrictions on pattern bindings:
2378 A pattern type signature can be on an arbitrary sub-pattern, not
2383 f ((x,y)::(a,b)) = (y,x) :: (b,a)
2392 Pattern type signatures, including the result part, can be used
2393 in lambda abstractions:
2396 (\ (x::a, y) :: a -> x)
2403 Pattern type signatures, including the result part, can be used
2404 in <literal>case</literal> expressions:
2408 case e of { (x::a, y) :: a -> x }
2416 To avoid ambiguity, the type after the “<literal>::</literal>” in a result
2417 pattern signature on a lambda or <literal>case</literal> must be atomic (i.e. a single
2418 token or a parenthesised type of some sort). To see why,
2419 consider how one would parse this:
2433 Pattern type signatures can bind existential type variables.
2438 data T = forall a. MkT [a]
2441 f (MkT [t::a]) = MkT t3
2454 Pattern type signatures that bind new type variables
2455 may not be used in pattern bindings at all.
2460 f x = let (y, z::a) = x in ...
2464 But these are OK, because they do not bind fresh type variables:
2468 f1 x = let (y, z::Int) = x in ...
2469 f2 (x::(Int,a)) = let (y, z::a) = x in ...
2473 However a single variable is considered a degenerate function binding,
2474 rather than a degerate pattern binding, so this is permitted, even
2475 though it binds a type variable:
2479 f :: (b->b) = \(x::b) -> x
2488 Such degnerate function bindings do not fall under the monomorphism
2495 g :: a -> a -> Bool = \x y. x==y
2501 Here <function>g</function> has type <literal>forall a. Eq a => a -> a -> Bool</literal>, just as if
2502 <function>g</function> had a separate type signature. Lacking a type signature, <function>g</function>
2503 would get a monomorphic type.
2511 <sect1 id="pragmas">
2516 GHC supports several pragmas, or instructions to the compiler placed
2517 in the source code. Pragmas don't affect the meaning of the program,
2518 but they might affect the efficiency of the generated code.
2521 <sect2 id="inline-pragma">
2522 <title>INLINE pragma
2524 <indexterm><primary>INLINE pragma</primary></indexterm>
2525 <indexterm><primary>pragma, INLINE</primary></indexterm></title>
2528 GHC (with <option>-O</option>, as always) tries to inline (or “unfold”)
2529 functions/values that are “small enough,” thus avoiding the call
2530 overhead and possibly exposing other more-wonderful optimisations.
2534 You will probably see these unfoldings (in Core syntax) in your
2539 Normally, if GHC decides a function is “too expensive” to inline, it
2540 will not do so, nor will it export that unfolding for other modules to
2545 The sledgehammer you can bring to bear is the
2546 <literal>INLINE</literal><indexterm><primary>INLINE pragma</primary></indexterm> pragma, used thusly:
2549 key_function :: Int -> String -> (Bool, Double)
2551 #ifdef __GLASGOW_HASKELL__
2552 {-# INLINE key_function #-}
2556 (You don't need to do the C pre-processor carry-on unless you're going
2557 to stick the code through HBC—it doesn't like <literal>INLINE</literal> pragmas.)
2561 The major effect of an <literal>INLINE</literal> pragma is to declare a function's
2562 “cost” to be very low. The normal unfolding machinery will then be
2563 very keen to inline it.
2567 An <literal>INLINE</literal> pragma for a function can be put anywhere its type
2568 signature could be put.
2572 <literal>INLINE</literal> pragmas are a particularly good idea for the
2573 <literal>then</literal>/<literal>return</literal> (or <literal>bind</literal>/<literal>unit</literal>) functions in a monad.
2574 For example, in GHC's own <literal>UniqueSupply</literal> monad code, we have:
2577 #ifdef __GLASGOW_HASKELL__
2578 {-# INLINE thenUs #-}
2579 {-# INLINE returnUs #-}
2587 <sect2 id="noinline-pragma">
2588 <title>NOINLINE pragma
2592 <indexterm><primary>NOINLINE pragma</primary></indexterm>
2593 <indexterm><primary>pragma, NOINLINE</primary></indexterm>
2597 The <literal>NOINLINE</literal> pragma does exactly what you'd expect: it stops the
2598 named function from being inlined by the compiler. You shouldn't ever
2599 need to do this, unless you're very cautious about code size.
2604 <sect2 id="specialize-pragma">
2605 <title>SPECIALIZE pragma</title>
2607 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2608 <indexterm><primary>pragma, SPECIALIZE</primary></indexterm>
2609 <indexterm><primary>overloading, death to</primary></indexterm>
2611 <para>(UK spelling also accepted.) For key overloaded
2612 functions, you can create extra versions (NB: more code space)
2613 specialised to particular types. Thus, if you have an
2614 overloaded function:</para>
2617 hammeredLookup :: Ord key => [(key, value)] -> key -> value
2620 <para>If it is heavily used on lists with
2621 <literal>Widget</literal> keys, you could specialise it as
2625 {-# SPECIALIZE hammeredLookup :: [(Widget, value)] -> Widget -> value #-}
2628 <para>To get very fancy, you can also specify a named function
2629 to use for the specialised value, as in:</para>
2632 {-# RULES hammeredLookup = blah #-}
2635 <para>where <literal>blah</literal> is an implementation of
2636 <literal>hammerdLookup</literal> written specialy for
2637 <literal>Widget</literal> lookups. It's <emphasis>Your
2638 Responsibility</emphasis> to make sure that
2639 <function>blah</function> really behaves as a specialised
2640 version of <function>hammeredLookup</function>!!!</para>
2642 <para>Note we use the <literal>RULE</literal> pragma here to
2643 indicate that <literal>hammeredLookup</literal> applied at a
2644 certain type should be replaced by <literal>blah</literal>. See
2645 <xref linkend="rules"> for more information on
2646 <literal>RULES</literal>.</para>
2648 <para>An example in which using <literal>RULES</literal> for
2649 specialisation will Win Big:
2652 toDouble :: Real a => a -> Double
2653 toDouble = fromRational . toRational
2655 {-# SPECIALIZE toDouble :: Int -> Double = i2d #-}
2656 i2d (I# i) = D# (int2Double# i) -- uses Glasgow prim-op directly
2659 The <function>i2d</function> function is virtually one machine
2660 instruction; the default conversion—via an intermediate
2661 <literal>Rational</literal>—is obscenely expensive by
2664 <para>A <literal>SPECIALIZE</literal> pragma for a function can
2665 be put anywhere its type signature could be put.</para>
2669 <sect2 id="specialize-instance-pragma">
2670 <title>SPECIALIZE instance pragma
2674 <indexterm><primary>SPECIALIZE pragma</primary></indexterm>
2675 <indexterm><primary>overloading, death to</primary></indexterm>
2676 Same idea, except for instance declarations. For example:
2679 instance (Eq a) => Eq (Foo a) where { ... usual stuff ... }
2681 {-# SPECIALIZE instance Eq (Foo [(Int, Bar)] #-}
2684 Compatible with HBC, by the way.
2689 <sect2 id="line-pragma">
2694 <indexterm><primary>LINE pragma</primary></indexterm>
2695 <indexterm><primary>pragma, LINE</primary></indexterm>
2699 This pragma is similar to C's <literal>#line</literal> pragma, and is mainly for use in
2700 automatically generated Haskell code. It lets you specify the line
2701 number and filename of the original code; for example
2707 {-# LINE 42 "Foo.vhs" #-}
2713 if you'd generated the current file from something called <filename>Foo.vhs</filename>
2714 and this line corresponds to line 42 in the original. GHC will adjust
2715 its error messages to refer to the line/file named in the <literal>LINE</literal>
2722 <title>RULES pragma</title>
2725 The RULES pragma lets you specify rewrite rules. It is described in
2726 <xref LinkEnd="rewrite-rules">.
2733 <sect1 id="rewrite-rules">
2734 <title>Rewrite rules
2736 <indexterm><primary>RULES pagma</primary></indexterm>
2737 <indexterm><primary>pragma, RULES</primary></indexterm>
2738 <indexterm><primary>rewrite rules</primary></indexterm></title>
2741 The programmer can specify rewrite rules as part of the source program
2742 (in a pragma). GHC applies these rewrite rules wherever it can.
2750 "map/map" forall f g xs. map f (map g xs) = map (f.g) xs
2757 <title>Syntax</title>
2760 From a syntactic point of view:
2766 Each rule has a name, enclosed in double quotes. The name itself has
2767 no significance at all. It is only used when reporting how many times the rule fired.
2773 There may be zero or more rules in a <literal>RULES</literal> pragma.
2779 Layout applies in a <literal>RULES</literal> pragma. Currently no new indentation level
2780 is set, so you must lay out your rules starting in the same column as the
2781 enclosing definitions.
2787 Each variable mentioned in a rule must either be in scope (e.g. <function>map</function>),
2788 or bound by the <literal>forall</literal> (e.g. <function>f</function>, <function>g</function>, <function>xs</function>). The variables bound by
2789 the <literal>forall</literal> are called the <emphasis>pattern</emphasis> variables. They are separated
2790 by spaces, just like in a type <literal>forall</literal>.
2796 A pattern variable may optionally have a type signature.
2797 If the type of the pattern variable is polymorphic, it <emphasis>must</emphasis> have a type signature.
2798 For example, here is the <literal>foldr/build</literal> rule:
2801 "fold/build" forall k z (g::forall b. (a->b->b) -> b -> b) .
2802 foldr k z (build g) = g k z
2805 Since <function>g</function> has a polymorphic type, it must have a type signature.
2812 The left hand side of a rule must consist of a top-level variable applied
2813 to arbitrary expressions. For example, this is <emphasis>not</emphasis> OK:
2816 "wrong1" forall e1 e2. case True of { True -> e1; False -> e2 } = e1
2817 "wrong2" forall f. f True = True
2820 In <literal>"wrong1"</literal>, the LHS is not an application; in <literal>"wrong2"</literal>, the LHS has a pattern variable
2827 A rule does not need to be in the same module as (any of) the
2828 variables it mentions, though of course they need to be in scope.
2834 Rules are automatically exported from a module, just as instance declarations are.
2845 <title>Semantics</title>
2848 From a semantic point of view:
2854 Rules are only applied if you use the <option>-O</option> flag.
2860 Rules are regarded as left-to-right rewrite rules.
2861 When GHC finds an expression that is a substitution instance of the LHS
2862 of a rule, it replaces the expression by the (appropriately-substituted) RHS.
2863 By "a substitution instance" we mean that the LHS can be made equal to the
2864 expression by substituting for the pattern variables.
2871 The LHS and RHS of a rule are typechecked, and must have the
2879 GHC makes absolutely no attempt to verify that the LHS and RHS
2880 of a rule have the same meaning. That is undecideable in general, and
2881 infeasible in most interesting cases. The responsibility is entirely the programmer's!
2888 GHC makes no attempt to make sure that the rules are confluent or
2889 terminating. For example:
2892 "loop" forall x,y. f x y = f y x
2895 This rule will cause the compiler to go into an infinite loop.
2902 If more than one rule matches a call, GHC will choose one arbitrarily to apply.
2908 GHC currently uses a very simple, syntactic, matching algorithm
2909 for matching a rule LHS with an expression. It seeks a substitution
2910 which makes the LHS and expression syntactically equal modulo alpha
2911 conversion. The pattern (rule), but not the expression, is eta-expanded if
2912 necessary. (Eta-expanding the epression can lead to laziness bugs.)
2913 But not beta conversion (that's called higher-order matching).
2917 Matching is carried out on GHC's intermediate language, which includes
2918 type abstractions and applications. So a rule only matches if the
2919 types match too. See <xref LinkEnd="rule-spec"> below.
2925 GHC keeps trying to apply the rules as it optimises the program.
2926 For example, consider:
2935 The expression <literal>s (t xs)</literal> does not match the rule <literal>"map/map"</literal>, but GHC
2936 will substitute for <VarName>s</VarName> and <VarName>t</VarName>, giving an expression which does match.
2937 If <VarName>s</VarName> or <VarName>t</VarName> was (a) used more than once, and (b) large or a redex, then it would
2938 not be substituted, and the rule would not fire.
2945 In the earlier phases of compilation, GHC inlines <emphasis>nothing
2946 that appears on the LHS of a rule</emphasis>, because once you have substituted
2947 for something you can't match against it (given the simple minded
2948 matching). So if you write the rule
2951 "map/map" forall f,g. map f . map g = map (f.g)
2954 this <emphasis>won't</emphasis> match the expression <literal>map f (map g xs)</literal>.
2955 It will only match something written with explicit use of ".".
2956 Well, not quite. It <emphasis>will</emphasis> match the expression
2962 where <function>wibble</function> is defined:
2965 wibble f g = map f . map g
2968 because <function>wibble</function> will be inlined (it's small).
2970 Later on in compilation, GHC starts inlining even things on the
2971 LHS of rules, but still leaves the rules enabled. This inlining
2972 policy is controlled by the per-simplification-pass flag <option>-finline-phase</option><emphasis>n</emphasis>.
2979 All rules are implicitly exported from the module, and are therefore
2980 in force in any module that imports the module that defined the rule, directly
2981 or indirectly. (That is, if A imports B, which imports C, then C's rules are
2982 in force when compiling A.) The situation is very similar to that for instance
2994 <title>List fusion</title>
2997 The RULES mechanism is used to implement fusion (deforestation) of common list functions.
2998 If a "good consumer" consumes an intermediate list constructed by a "good producer", the
2999 intermediate list should be eliminated entirely.
3003 The following are good producers:
3015 Enumerations of <literal>Int</literal> and <literal>Char</literal> (e.g. <literal>['a'..'z']</literal>).
3021 Explicit lists (e.g. <literal>[True, False]</literal>)
3027 The cons constructor (e.g <literal>3:4:[]</literal>)
3033 <function>++</function>
3039 <function>map</function>
3045 <function>filter</function>
3051 <function>iterate</function>, <function>repeat</function>
3057 <function>zip</function>, <function>zipWith</function>
3066 The following are good consumers:
3078 <function>array</function> (on its second argument)
3084 <function>length</function>
3090 <function>++</function> (on its first argument)
3096 <function>map</function>
3102 <function>filter</function>
3108 <function>concat</function>
3114 <function>unzip</function>, <function>unzip2</function>, <function>unzip3</function>, <function>unzip4</function>
3120 <function>zip</function>, <function>zipWith</function> (but on one argument only; if both are good producers, <function>zip</function>
3121 will fuse with one but not the other)
3127 <function>partition</function>
3133 <function>head</function>
3139 <function>and</function>, <function>or</function>, <function>any</function>, <function>all</function>
3145 <function>sequence_</function>
3151 <function>msum</function>
3157 <function>sortBy</function>
3166 So, for example, the following should generate no intermediate lists:
3169 array (1,10) [(i,i*i) | i <- map (+ 1) [0..9]]
3175 This list could readily be extended; if there are Prelude functions that you use
3176 a lot which are not included, please tell us.
3180 If you want to write your own good consumers or producers, look at the
3181 Prelude definitions of the above functions to see how to do so.
3186 <sect2 id="rule-spec">
3187 <title>Specialisation
3191 Rewrite rules can be used to get the same effect as a feature
3192 present in earlier version of GHC:
3195 {-# SPECIALIZE fromIntegral :: Int8 -> Int16 = int8ToInt16 #-}
3198 This told GHC to use <function>int8ToInt16</function> instead of <function>fromIntegral</function> whenever
3199 the latter was called with type <literal>Int8 -> Int16</literal>. That is, rather than
3200 specialising the original definition of <function>fromIntegral</function> the programmer is
3201 promising that it is safe to use <function>int8ToInt16</function> instead.
3205 This feature is no longer in GHC. But rewrite rules let you do the
3210 "fromIntegral/Int8/Int16" fromIntegral = int8ToInt16
3214 This slightly odd-looking rule instructs GHC to replace <function>fromIntegral</function>
3215 by <function>int8ToInt16</function> <emphasis>whenever the types match</emphasis>. Speaking more operationally,
3216 GHC adds the type and dictionary applications to get the typed rule
3219 forall (d1::Integral Int8) (d2::Num Int16) .
3220 fromIntegral Int8 Int16 d1 d2 = int8ToInt16
3224 this rule does not need to be in the same file as fromIntegral,
3225 unlike the <literal>SPECIALISE</literal> pragmas which currently do (so that they
3226 have an original definition available to specialise).
3232 <title>Controlling what's going on</title>
3240 Use <option>-ddump-rules</option> to see what transformation rules GHC is using.
3246 Use <option>-ddump-simpl-stats</option> to see what rules are being fired.
3247 If you add <option>-dppr-debug</option> you get a more detailed listing.
3253 The defintion of (say) <function>build</function> in <FileName>PrelBase.lhs</FileName> looks llike this:
3256 build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
3257 {-# INLINE build #-}
3261 Notice the <literal>INLINE</literal>! That prevents <literal>(:)</literal> from being inlined when compiling
3262 <literal>PrelBase</literal>, so that an importing module will “see” the <literal>(:)</literal>, and can
3263 match it on the LHS of a rule. <literal>INLINE</literal> prevents any inlining happening
3264 in the RHS of the <literal>INLINE</literal> thing. I regret the delicacy of this.
3271 In <filename>ghc/lib/std/PrelBase.lhs</filename> look at the rules for <function>map</function> to
3272 see how to write rules that will do fusion and yet give an efficient
3273 program even if fusion doesn't happen. More rules in <filename>PrelList.lhs</filename>.
3285 <sect1 id="generic-classes">
3286 <title>Generic classes</title>
3289 The ideas behind this extension are described in detail in "Derivable type classes",
3290 Ralf Hinze and Simon Peyton Jones, Haskell Workshop, Montreal Sept 2000, pp94-105.
3291 An example will give the idea:
3299 fromBin :: [Int] -> (a, [Int])
3301 toBin {| Unit |} Unit = []
3302 toBin {| a :+: b |} (Inl x) = 0 : toBin x
3303 toBin {| a :+: b |} (Inr y) = 1 : toBin y
3304 toBin {| a :*: b |} (x :*: y) = toBin x ++ toBin y
3306 fromBin {| Unit |} bs = (Unit, bs)
3307 fromBin {| a :+: b |} (0:bs) = (Inl x, bs') where (x,bs') = fromBin bs
3308 fromBin {| a :+: b |} (1:bs) = (Inr y, bs') where (y,bs') = fromBin bs
3309 fromBin {| a :*: b |} bs = (x :*: y, bs'') where (x,bs' ) = fromBin bs
3310 (y,bs'') = fromBin bs'
3313 This class declaration explains how <literal>toBin</literal> and <literal>fromBin</literal>
3314 work for arbitrary data types. They do so by giving cases for unit, product, and sum,
3315 which are defined thus in the library module <literal>Generics</literal>:
3319 data a :+: b = Inl a | Inr b
3320 data a :*: b = a :*: b
3323 Now you can make a data type into an instance of Bin like this:
3325 instance (Bin a, Bin b) => Bin (a,b)
3326 instance Bin a => Bin [a]
3328 That is, just leave off the "where" clasuse. Of course, you can put in the
3329 where clause and over-ride whichever methods you please.
3333 <title> Using generics </title>
3334 <para>To use generics you need to</para>
3337 <para>Use the flags <option>-fglasgow-exts</option> (to enable the extra syntax),
3338 <option>-fgenerics</option> (to generate extra per-data-type code),
3339 and <option>-package lang</option> (to make the <literal>Generics</literal> library
3343 <para>Import the module <literal>Generics</literal> from the
3344 <literal>lang</literal> package. This import brings into
3345 scope the data types <literal>Unit</literal>,
3346 <literal>:*:</literal>, and <literal>:+:</literal>. (You
3347 don't need this import if you don't mention these types
3348 explicitly; for example, if you are simply giving instance
3349 declarations.)</para>
3354 <sect2> <title> Changes wrt the paper </title>
3356 Note that the type constructors <literal>:+:</literal> and <literal>:*:</literal>
3357 can be written infix (indeed, you can now use
3358 any operator starting in a colon as an infix type constructor). Also note that
3359 the type constructors are not exactly as in the paper (Unit instead of 1, etc).
3360 Finally, note that the syntax of the type patterns in the class declaration
3361 uses "<literal>{|</literal>" and "<literal>|}</literal>" brackets; curly braces
3362 alone would ambiguous when they appear on right hand sides (an extension we
3363 anticipate wanting).
3367 <sect2> <title>Terminology and restrictions</title>
3369 Terminology. A "generic default method" in a class declaration
3370 is one that is defined using type patterns as above.
3371 A "polymorphic default method" is a default method defined as in Haskell 98.
3372 A "generic class declaration" is a class declaration with at least one
3373 generic default method.
3381 Alas, we do not yet implement the stuff about constructor names and
3388 A generic class can have only one parameter; you can't have a generic
3389 multi-parameter class.
3395 A default method must be defined entirely using type patterns, or entirely
3396 without. So this is illegal:
3399 op :: a -> (a, Bool)
3400 op {| Unit |} Unit = (Unit, True)
3403 However it is perfectly OK for some methods of a generic class to have
3404 generic default methods and others to have polymorphic default methods.
3410 The type variable(s) in the type pattern for a generic method declaration
3411 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:
3415 op {| p :*: q |} (x :*: y) = op (x :: p)
3423 The type patterns in a generic default method must take one of the forms:
3429 where "a" and "b" are type variables. Furthermore, all the type patterns for
3430 a single type constructor (<literal>:*:</literal>, say) must be identical; they
3431 must use the same type variables. So this is illegal:
3435 op {| a :+: b |} (Inl x) = True
3436 op {| p :+: q |} (Inr y) = False
3438 The type patterns must be identical, even in equations for different methods of the class.
3439 So this too is illegal:
3443 op {| a :*: b |} (Inl x) = True
3446 op {| p :*: q |} (Inr y) = False
3448 (The reason for this restriction is that we gather all the equations for a particular type consructor
3449 into a single generic instance declaration.)
3455 A generic method declaration must give a case for each of the three type constructors.
3461 The type for a generic method can be built only from:
3463 <listitem> <para> Function arrows </para> </listitem>
3464 <listitem> <para> Type variables </para> </listitem>
3465 <listitem> <para> Tuples </para> </listitem>
3466 <listitem> <para> Arbitrary types not involving type variables </para> </listitem>
3468 Here are some example type signatures for generic methods:
3471 op2 :: Bool -> (a,Bool)
3472 op3 :: [Int] -> a -> a
3475 Here, op1, op2, op3 are OK, but op4 is rejected, because it has a type variable
3479 This restriction is an implementation restriction: we just havn't got around to
3480 implementing the necessary bidirectional maps over arbitrary type constructors.
3481 It would be relatively easy to add specific type constructors, such as Maybe and list,
3482 to the ones that are allowed.</para>
3487 In an instance declaration for a generic class, the idea is that the compiler
3488 will fill in the methods for you, based on the generic templates. However it can only
3493 The instance type is simple (a type constructor applied to type variables, as in Haskell 98).
3498 No constructor of the instance type has unboxed fields.
3502 (Of course, these things can only arise if you are already using GHC extensions.)
3503 However, you can still give an instance declarations for types which break these rules,
3504 provided you give explicit code to override any generic default methods.
3512 The option <option>-ddump-deriv</option> dumps incomprehensible stuff giving details of
3513 what the compiler does with generic declarations.
3518 <sect2> <title> Another example </title>
3520 Just to finish with, here's another example I rather like:
3524 nCons {| Unit |} _ = 1
3525 nCons {| a :*: b |} _ = 1
3526 nCons {| a :+: b |} _ = nCons (bot::a) + nCons (bot::b)
3529 tag {| Unit |} _ = 1
3530 tag {| a :*: b |} _ = 1
3531 tag {| a :+: b |} (Inl x) = tag x
3532 tag {| a :+: b |} (Inr y) = nCons (bot::a) + tag y
3539 ;;; Local Variables: ***
3541 ;;; sgml-parent-document: ("users_guide.sgml" "book" "chapter" "sect1") ***
projects / ghc-hetmet.git / blob