X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=8bca4857c5840fd55b658d0215077c8c94b2516d;hb=f7c548fd652b99e7e2e4069ecd7ce2a5821d33ae;hp=6f54d1e0c2f09bb7f17f0bc134cf593e0d3e8a55;hpb=646ca6ffb55b1a9ee4c71e8573d87629dc7a4989;p=ghc-hetmet.git
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index 6f54d1e..8bca485 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -241,6 +241,14 @@ documentation describes all the libraries that come with GHC.
+
+
+ Enables overloaded string literals (see ).
+
+
+
+ Enables lexically-scoped type variables (see
-clunky env var1 var1 = case lookup env var1 of
+clunky env var1 var2 = case lookup env var1 of
Nothing -> fail
Just val1 -> case lookup env var2 of
Nothing -> fail
@@ -645,7 +653,7 @@ Here is how I would write clunky:
-clunky env var1 var1
+clunky env var1 var2
| Just val1 <- lookup env var1
, Just val2 <- lookup env var2
= val1 + val2
@@ -939,14 +947,10 @@ definitions; you must define such a function in prefix form.
-
-Type system extensions
-
-
-
-Data types and type synonyms
+
+Extensions to data types and type synonyms
-
+Data types with no constructorsWith the flag, GHC lets you declare
@@ -964,9 +968,9 @@ not * then an explicit kind annotation must be used
Such data types have only one value, namely bottom.
Nevertheless, they can be useful when defining "phantom types".
-
+
-
+Infix type constructors, classes, and type variables
@@ -1033,9 +1037,9 @@ to be written infix, very much like expressions. More specifically:
-
+
-
+Liberalised type synonyms
@@ -1125,10 +1129,10 @@ this will be rejected:
because GHC does not allow unboxed tuples on the left of a function arrow.
-
+
-
+Existentially quantified data constructors
@@ -1527,11 +1531,11 @@ declarations. Define your own instances!
-
+
-
+Declaring data types with explicit constructor signaturesGHC allows you to declare an algebraic data type by
@@ -1719,9 +1723,9 @@ As before, only one selector function is generated here, that for tag
-
+
-
+Generalised Algebraic Data Types (GADTs)Generalised Algebraic Data Types generalise ordinary algebraic data types
@@ -1833,164 +1837,424 @@ their selector functions actually have different types:
-
-
-
-
-
+
-
-Class declarations
+
+Deriving clause for classes <literal>Typeable</literal> and <literal>Data</literal>
-This section, and the next one, documents GHC's type-class extensions.
-There's lots of background in the paper Type
-classes: exploring the design space (Simon Peyton Jones, Mark
-Jones, Erik Meijer).
+Haskell 98 allows the programmer to add "deriving( Eq, Ord )" to a data type
+declaration, to generate a standard instance declaration for classes specified in the deriving clause.
+In Haskell 98, the only classes that may appear in the deriving clause are the standard
+classes Eq, Ord,
+Enum, Ix, Bounded, Read, and Show.
-All the extensions are enabled by the flag.
+GHC extends this list with two more classes that may be automatically derived
+(provided the flag is specified):
+Typeable, and Data. These classes are defined in the library
+modules Data.Typeable and Data.Generics respectively, and the
+appropriate class must be in scope before it can be mentioned in the deriving clause.
-
-
-Multi-parameter type classes
-
-Multi-parameter type classes are permitted. For example:
-
-
-
- class Collection c a where
- union :: c a -> c a -> c a
- ...etc.
-
-
+An instance of Typeable can only be derived if the
+data type has seven or fewer type parameters, all of kind *.
+The reason for this is that the Typeable class is derived using the scheme
+described in
+
+Scrap More Boilerplate: Reflection, Zips, and Generalised Casts
+.
+(Section 7.4 of the paper describes the multiple Typeable classes that
+are used, and only Typeable1 up to
+Typeable7 are provided in the library.)
+In other cases, there is nothing to stop the programmer writing a TypableX
+class, whose kind suits that of the data type constructor, and
+then writing the data type instance by hand.
-
+
-
-The superclasses of a class declaration
+
+Generalised derived instances for newtypes
-There are no restrictions on the context in a class declaration
-(which introduces superclasses), except that the class hierarchy must
-be acyclic. So these class declarations are OK:
+When you define an abstract type using newtype, you may want
+the new type to inherit some instances from its representation. In
+Haskell 98, you can inherit instances of Eq, Ord,
+Enum and Bounded by deriving them, but for any
+other classes you have to write an explicit instance declaration. For
+example, if you define
+
+ newtype Dollars = Dollars Int
+
-
- class Functor (m k) => FiniteMap m k where
- ...
+and you want to use arithmetic on Dollars, you have to
+explicitly define an instance of Num:
- class (Monad m, Monad (t m)) => Transform t m where
- lift :: m a -> (t m) a
+
+ instance Num Dollars where
+ Dollars a + Dollars b = Dollars (a+b)
+ ...
-
-
+All the instance does is apply and remove the newtype
+constructor. It is particularly galling that, since the constructor
+doesn't appear at run-time, this instance declaration defines a
+dictionary which is wholly equivalent to the Int
+dictionary, only slower!
-
-As in Haskell 98, The class hierarchy must be acyclic. However, the definition
-of "acyclic" involves only the superclass relationships. For example,
-this is OK:
-
- class C a where {
- op :: D b => a -> b -> b
- }
+ Generalising the deriving clause
+
+GHC now permits such instances to be derived instead, so one can write
+
+ newtype Dollars = Dollars Int deriving (Eq,Show,Num)
+
- class C a => D a where { ... }
-
+and the implementation uses the sameNum dictionary
+for Dollars as for Int. Notionally, the compiler
+derives an instance declaration of the form
+
+ instance Num Int => Num Dollars
+
-Here, C is a superclass of D, but it's OK for a
-class operation op of C to mention D. (It
-would not be OK for D to be a superclass of C.)
+which just adds or removes the newtype constructor according to the type.
-
-
+
+We can also derive instances of constructor classes in a similar
+way. For example, suppose we have implemented state and failure monad
+transformers, such that
+
+ instance Monad m => Monad (State s m)
+ instance Monad m => Monad (Failure m)
+
+In Haskell 98, we can define a parsing monad by
+
+ type Parser tok m a = State [tok] (Failure m) a
+
-
-Class method types
+which is automatically a monad thanks to the instance declarations
+above. With the extension, we can make the parser type abstract,
+without needing to write an instance of class Monad, via
-
-Haskell 98 prohibits class method types to mention constraints on the
-class type variable, thus:
-
- class Seq s a where
- fromList :: [a] -> s a
- elem :: Eq a => a -> s a -> Bool
+
+ newtype Parser tok m a = Parser (State [tok] (Failure m) a)
+ deriving Monad
-The type of elem is illegal in Haskell 98, because it
-contains the constraint Eq a, constrains only the
-class type variable (in this case a).
-GHC lifts this restriction.
+In this case the derived instance declaration is of the form
+
+ instance Monad (State [tok] (Failure m)) => Monad (Parser tok m)
+
+
+Notice that, since Monad is a constructor class, the
+instance is a partial application of the new type, not the
+entire left hand side. We can imagine that the type declaration is
+``eta-converted'' to generate the context of the instance
+declaration.
+
+We can even derive instances of multi-parameter classes, provided the
+newtype is the last class parameter. In this case, a ``partial
+application'' of the class appears in the deriving
+clause. For example, given the class
-
-
+
+ class StateMonad s m | m -> s where ...
+ instance Monad m => StateMonad s (State s m) where ...
+
+then we can derive an instance of StateMonad for Parsers by
+
+ newtype Parser tok m a = Parser (State [tok] (Failure m) a)
+ deriving (Monad, StateMonad [tok])
+
-
-Functional dependencies
-
+The derived instance is obtained by completing the application of the
+class to the new type:
- Functional dependencies are implemented as described by Mark Jones
-in “Type Classes with Functional Dependencies”, Mark P. Jones,
-In Proceedings of the 9th European Symposium on Programming,
-ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782,
-.
+
+ instance StateMonad [tok] (State [tok] (Failure m)) =>
+ StateMonad [tok] (Parser tok m)
+
-Functional dependencies are introduced by a vertical bar in the syntax of a
-class declaration; e.g.
-
- class (Monad m) => MonadState s m | m -> s where ...
- class Foo a b c | a b -> c where ...
-
-There should be more documentation, but there isn't (yet). Yell if you need it.
+As a result of this extension, all derived instances in newtype
+ declarations are treated uniformly (and implemented just by reusing
+the dictionary for the representation type), except
+Show and Read, which really behave differently for
+the newtype and its representation.
+
-Rules for functional dependencies
+ A more precise specification
-In a class declaration, all of the class type variables must be reachable (in the sense
-mentioned in )
-from the free variables of each method type.
-For example:
-
-
- class Coll s a where
- empty :: s
- insert :: s -> a -> s
-
-
-is not OK, because the type of empty doesn't mention
-a. Functional dependencies can make the type variable
-reachable:
-
- class Coll s a | s -> a where
- empty :: s
- insert :: s -> a -> s
-
-
-Alternatively Coll might be rewritten
-
-
- class Coll s a where
- empty :: s a
- insert :: s a -> a -> s a
-
+Derived instance declarations are constructed as follows. Consider the
+declaration (after expansion of any type synonyms)
+
+ newtype T v1...vn = T' (t vk+1...vn) deriving (c1...cm)
+
-which makes the connection between the type of a collection of
-a's (namely (s a)) and the element type a.
-Occasionally this really doesn't work, in which case you can split the
-class like this:
+where
+
+
+ The ci are partial applications of
+ classes of the form C t1'...tj', where the arity of C
+ is exactly j+1. That is, C lacks exactly one type argument.
+
+
+ The k is chosen so that ci (T v1...vk) is well-kinded.
+
+
+ The type t is an arbitrary type.
+
+
+ The type variables vk+1...vn do not occur in t,
+ nor in the ci, and
+
+
+ None of the ci is Read, Show,
+ Typeable, or Data. These classes
+ should not "look through" the type or its constructor. You can still
+ derive these classes for a newtype, but it happens in the usual way, not
+ via this new mechanism.
+
+
+Then, for each ci, the derived instance
+declaration is:
+
+ instance ci t => ci (T v1...vk)
+
+As an example which does not work, consider
+
+ newtype NonMonad m s = NonMonad (State s m s) deriving Monad
+
+Here we cannot derive the instance
+
+ instance Monad (State s m) => Monad (NonMonad m)
+
+
+because the type variable s occurs in State s m,
+and so cannot be "eta-converted" away. It is a good thing that this
+deriving clause is rejected, because NonMonad m is
+not, in fact, a monad --- for the same reason. Try defining
+>>= with the correct type: you won't be able to.
+
+
+
+Notice also that the order of class parameters becomes
+important, since we can only derive instances for the last one. If the
+StateMonad class above were instead defined as
+
+
+ class StateMonad m s | m -> s where ...
+
+
+then we would not have been able to derive an instance for the
+Parser type above. We hypothesise that multi-parameter
+classes usually have one "main" parameter for which deriving new
+instances is most interesting.
+
+Lastly, all of this applies only for classes other than
+Read, Show, Typeable,
+and Data, for which the built-in derivation applies (section
+4.3.3. of the Haskell Report).
+(For the standard classes Eq, Ord,
+Ix, and Bounded it is immaterial whether
+the standard method is used or the one described here.)
+
+
+
+
+
+
+Stand-alone deriving declarations
+
+
+GHC now allows stand-alone deriving declarations, enabled by -fglasgow-exts:
+
+ data Foo a = Bar a | Baz String
+
+ derive instance Eq (Foo a)
+
+The token "derive" is a keyword only when followed by "instance";
+you can use it as a variable name elsewhere.
+The stand-alone syntax is generalised for newtypes in exactly the same
+way that ordinary deriving clauses are generalised ().
+For example:
+
+ newtype Foo a = MkFoo (State Int a)
+
+ derive instance MonadState Int Foo
+
+GHC always treats the last parameter of the instance
+(Foo in this exmample) as the type whose instance is being derived.
+
+
+
+
+
+
+
+
+
+Other type system extensions
+
+
+Class declarations
+
+
+This section, and the next one, documents GHC's type-class extensions.
+There's lots of background in the paper Type
+classes: exploring the design space (Simon Peyton Jones, Mark
+Jones, Erik Meijer).
+
+
+All the extensions are enabled by the flag.
+
+
+
+Multi-parameter type classes
+
+Multi-parameter type classes are permitted. For example:
+
+
+
+ class Collection c a where
+ union :: c a -> c a -> c a
+ ...etc.
+
+
+
+
+
+
+The superclasses of a class declaration
+
+
+There are no restrictions on the context in a class declaration
+(which introduces superclasses), except that the class hierarchy must
+be acyclic. So these class declarations are OK:
+
+
+
+ class Functor (m k) => FiniteMap m k where
+ ...
+
+ class (Monad m, Monad (t m)) => Transform t m where
+ lift :: m a -> (t m) a
+
+
+
+
+
+As in Haskell 98, The class hierarchy must be acyclic. However, the definition
+of "acyclic" involves only the superclass relationships. For example,
+this is OK:
+
+
+
+ class C a where {
+ op :: D b => a -> b -> b
+ }
+
+ class C a => D a where { ... }
+
+
+
+Here, C is a superclass of D, but it's OK for a
+class operation op of C to mention D. (It
+would not be OK for D to be a superclass of C.)
+
+
+
+
+
+
+
+Class method types
+
+
+Haskell 98 prohibits class method types to mention constraints on the
+class type variable, thus:
+
+ class Seq s a where
+ fromList :: [a] -> s a
+ elem :: Eq a => a -> s a -> Bool
+
+The type of elem is illegal in Haskell 98, because it
+contains the constraint Eq a, constrains only the
+class type variable (in this case a).
+GHC lifts this restriction.
+
+
+
+
+
+
+
+Functional dependencies
+
+
+ Functional dependencies are implemented as described by Mark Jones
+in “Type Classes with Functional Dependencies”, Mark P. Jones,
+In Proceedings of the 9th European Symposium on Programming,
+ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782,
+.
+
+
+Functional dependencies are introduced by a vertical bar in the syntax of a
+class declaration; e.g.
+
+ class (Monad m) => MonadState s m | m -> s where ...
+
+ class Foo a b c | a b -> c where ...
+
+There should be more documentation, but there isn't (yet). Yell if you need it.
+
+
+Rules for functional dependencies
+
+In a class declaration, all of the class type variables must be reachable (in the sense
+mentioned in )
+from the free variables of each method type.
+For example:
+
+
+ class Coll s a where
+ empty :: s
+ insert :: s -> a -> s
+
+
+is not OK, because the type of empty doesn't mention
+a. Functional dependencies can make the type variable
+reachable:
+
+ class Coll s a | s -> a where
+ empty :: s
+ insert :: s -> a -> s
+
+
+Alternatively Coll might be rewritten
+
+
+ class Coll s a where
+ empty :: s a
+ insert :: s a -> a -> s a
+
+
+
+which makes the connection between the type of a collection of
+a's (namely (s a)) and the element type a.
+Occasionally this really doesn't work, in which case you can split the
+class like this:
@@ -2700,54 +2964,6 @@ territory free in case we need it later.
-
-For-all hoisting
-
-It is often convenient to use generalised type synonyms (see ) at the right hand
-end of an arrow, thus:
-
- type Discard a = forall b. a -> b -> a
-
- g :: Int -> Discard Int
- g x y z = x+y
-
-Simply expanding the type synonym would give
-
- g :: Int -> (forall b. Int -> b -> Int)
-
-but GHC "hoists" the forall to give the isomorphic type
-
- g :: forall b. Int -> Int -> b -> Int
-
-In general, the rule is this: to determine the type specified by any explicit
-user-written type (e.g. in a type signature), GHC expands type synonyms and then repeatedly
-performs the transformation:
-
- type1 -> forall a1..an. context2 => type2
-==>
- forall a1..an. context2 => type1 -> type2
-
-(In fact, GHC tries to retain as much synonym information as possible for use in
-error messages, but that is a usability issue.) This rule applies, of course, whether
-or not the forall comes from a synonym. For example, here is another
-valid way to write g's type signature:
-
- g :: Int -> Int -> forall b. b -> Int
-
-
-
-When doing this hoisting operation, GHC eliminates duplicate constraints. For
-example:
-
- type Foo a = (?x::Int) => Bool -> a
- g :: Foo (Foo Int)
-
-means
-
- g :: (?x::Int) => Bool -> Bool -> Int
-
-
-
@@ -3250,6 +3466,8 @@ For example, all the following types are legal:
g2 :: (forall a. Eq a => [a] -> a -> Bool) -> Int -> Int
f3 :: ((forall a. a->a) -> Int) -> Bool -> Bool
+
+ f4 :: Int -> (forall a. a -> a)
Here, f1 and g1 are rank-1 types, and
can be written in standard Haskell (e.g. f1 :: a->b->a).
@@ -3272,7 +3490,8 @@ that restriction has now been lifted.)
In particular, a forall-type (also called a "type scheme"),
including an operational type class context, is legal:
- On the left of a function arrow
+ On the left or right (see f4, for example)
+of a function arrow On the right of a function arrow (see ) As the argument of a constructor, or type of a field, in a data type declaration. For
example, any of the f1,f2,f3,g1,g2 above would be valid
@@ -3280,14 +3499,6 @@ field type signatures. As the type of an implicit parameter In a pattern type signature (see )
-There is one place you cannot put a forall:
-you cannot instantiate a type variable with a forall-type. So you cannot
-make a forall-type the argument of a type constructor. So these types are illegal:
-
- x1 :: [forall a. a->a]
- x2 :: (forall a. a->a, Int)
- x3 :: Maybe (forall a. a->a)
-
Of course forall becomes a keyword; you can't use forall as
a type variable any more!
@@ -3635,418 +3846,161 @@ the definition of "f".
This only happens if the quantification in f's type
signature is explicit. For example:
-
- g :: [a] -> [a]
- g (x:xs) = xs ++ [ x :: a ]
-
-This program will be rejected, because "a" does not scope
-over the definition of "f", so "x::a"
-means "x::forall a. a" by Haskell's usual implicit
-quantification rules.
-
-
-
-
-Expression type signatures
-
-An expression type signature that has explicit
-quantification (using forall) brings into scope the
-explicitly-quantified
-type variables, in the annotated expression. For example:
-
- f = runST ( (op >>= \(x :: STRef s Int) -> g x) :: forall s. ST s Bool )
-
-Here, the type signature forall a. ST s Bool brings the
-type variable s into scope, in the annotated expression
-(op >>= \(x :: STRef s Int) -> g x).
-
-
-
-
-
-Pattern type signatures
-
-A type signature may occur in any pattern; this is a pattern type
-signature.
-For example:
-
- -- f and g assume that 'a' is already in scope
- f = \(x::Int, y::a) -> x
- g (x::a) = x
- h ((x,y) :: (Int,Bool)) = (y,x)
-
-In the case where all the type variables in the pattern type sigature are
-already in scope (i.e. bound by the enclosing context), matters are simple: the
-signature simply constrains the type of the pattern in the obvious way.
-
-
-There is only one situation in which you can write a pattern type signature that
-mentions a type variable that is not already in scope, namely in pattern match
-of an existential data constructor. For example:
-
- data T = forall a. MkT [a]
-
- k :: T -> T
- k (MkT [t::a]) = MkT t3
- where
- t3::[a] = [t,t,t]
-
-Here, the pattern type signature (t::a) mentions a lexical type
-variable that is not already in scope. Indeed, it cannot already be in scope,
-because it is bound by the pattern match. GHC's rule is that in this situation
-(and only then), a pattern type signature can mention a type variable that is
-not already in scope; the effect is to bring it into scope, standing for the
-existentially-bound type variable.
-
-
-If this seems a little odd, we think so too. But we must have
-some way to bring such type variables into scope, else we
-could not name existentially-bound type variables in subequent type signatures.
-
-
-This is (now) the only situation in which a pattern type
-signature is allowed to mention a lexical variable that is not already in
-scope.
-For example, both f and g would be
-illegal if a was not already in scope.
-
-
-
-
-
-
-
-
-Class and instance declarations
-
-
-The type variables in the head of a class or instance declaration
-scope over the methods defined in the where part. For example:
-
-
-
- class C a where
- op :: [a] -> a
-
- op xs = let ys::[a]
- ys = reverse xs
- in
- head ys
-
-
-
-
-
-
-
-Deriving clause for classes <literal>Typeable</literal> and <literal>Data</literal>
-
-
-Haskell 98 allows the programmer to add "deriving( Eq, Ord )" to a data type
-declaration, to generate a standard instance declaration for classes specified in the deriving clause.
-In Haskell 98, the only classes that may appear in the deriving clause are the standard
-classes Eq, Ord,
-Enum, Ix, Bounded, Read, and Show.
-
-
-GHC extends this list with two more classes that may be automatically derived
-(provided the flag is specified):
-Typeable, and Data. These classes are defined in the library
-modules Data.Typeable and Data.Generics respectively, and the
-appropriate class must be in scope before it can be mentioned in the deriving clause.
-
-An instance of Typeable can only be derived if the
-data type has seven or fewer type parameters, all of kind *.
-The reason for this is that the Typeable class is derived using the scheme
-described in
-
-Scrap More Boilerplate: Reflection, Zips, and Generalised Casts
-.
-(Section 7.4 of the paper describes the multiple Typeable classes that
-are used, and only Typeable1 up to
-Typeable7 are provided in the library.)
-In other cases, there is nothing to stop the programmer writing a TypableX
-class, whose kind suits that of the data type constructor, and
-then writing the data type instance by hand.
-
-
-
-
-Generalised derived instances for newtypes
-
-
-When you define an abstract type using newtype, you may want
-the new type to inherit some instances from its representation. In
-Haskell 98, you can inherit instances of Eq, Ord,
-Enum and Bounded by deriving them, but for any
-other classes you have to write an explicit instance declaration. For
-example, if you define
-
-
- newtype Dollars = Dollars Int
-
-
-and you want to use arithmetic on Dollars, you have to
-explicitly define an instance of Num:
-
-
- instance Num Dollars where
- Dollars a + Dollars b = Dollars (a+b)
- ...
-
-All the instance does is apply and remove the newtype
-constructor. It is particularly galling that, since the constructor
-doesn't appear at run-time, this instance declaration defines a
-dictionary which is wholly equivalent to the Int
-dictionary, only slower!
-
-
-
- Generalising the deriving clause
-
-GHC now permits such instances to be derived instead, so one can write
-
- newtype Dollars = Dollars Int deriving (Eq,Show,Num)
-
-
-and the implementation uses the sameNum dictionary
-for Dollars as for Int. Notionally, the compiler
-derives an instance declaration of the form
-
-
- instance Num Int => Num Dollars
-
-
-which just adds or removes the newtype constructor according to the type.
-
-
-
-We can also derive instances of constructor classes in a similar
-way. For example, suppose we have implemented state and failure monad
-transformers, such that
-
-
- instance Monad m => Monad (State s m)
- instance Monad m => Monad (Failure m)
-
-In Haskell 98, we can define a parsing monad by
-
- type Parser tok m a = State [tok] (Failure m) a
-
-
-which is automatically a monad thanks to the instance declarations
-above. With the extension, we can make the parser type abstract,
-without needing to write an instance of class Monad, via
-
-
- newtype Parser tok m a = Parser (State [tok] (Failure m) a)
- deriving Monad
+
+ g :: [a] -> [a]
+ g (x:xs) = xs ++ [ x :: a ]
-In this case the derived instance declaration is of the form
-
- instance Monad (State [tok] (Failure m)) => Monad (Parser tok m)
-
-
-Notice that, since Monad is a constructor class, the
-instance is a partial application of the new type, not the
-entire left hand side. We can imagine that the type declaration is
-``eta-converted'' to generate the context of the instance
-declaration.
+This program will be rejected, because "a" does not scope
+over the definition of "f", so "x::a"
+means "x::forall a. a" by Haskell's usual implicit
+quantification rules.
-
+
-We can even derive instances of multi-parameter classes, provided the
-newtype is the last class parameter. In this case, a ``partial
-application'' of the class appears in the deriving
-clause. For example, given the class
+
+Expression type signatures
-
- class StateMonad s m | m -> s where ...
- instance Monad m => StateMonad s (State s m) where ...
-
-then we can derive an instance of StateMonad for Parsers by
-
- newtype Parser tok m a = Parser (State [tok] (Failure m) a)
- deriving (Monad, StateMonad [tok])
+An expression type signature that has explicit
+quantification (using forall) brings into scope the
+explicitly-quantified
+type variables, in the annotated expression. For example:
+
+ f = runST ( (op >>= \(x :: STRef s Int) -> g x) :: forall s. ST s Bool )
+Here, the type signature forall a. ST s Bool brings the
+type variable s into scope, in the annotated expression
+(op >>= \(x :: STRef s Int) -> g x).
+
-The derived instance is obtained by completing the application of the
-class to the new type:
+
-
- instance StateMonad [tok] (State [tok] (Failure m)) =>
- StateMonad [tok] (Parser tok m)
+
+Pattern type signatures
+
+A type signature may occur in any pattern; this is a pattern type
+signature.
+For example:
+
+ -- f and g assume that 'a' is already in scope
+ f = \(x::Int, y::a) -> x
+ g (x::a) = x
+ h ((x,y) :: (Int,Bool)) = (y,x)
+In the case where all the type variables in the pattern type sigature are
+already in scope (i.e. bound by the enclosing context), matters are simple: the
+signature simply constrains the type of the pattern in the obvious way.
+There is only one situation in which you can write a pattern type signature that
+mentions a type variable that is not already in scope, namely in pattern match
+of an existential data constructor. For example:
+
+ data T = forall a. MkT [a]
-As a result of this extension, all derived instances in newtype
- declarations are treated uniformly (and implemented just by reusing
-the dictionary for the representation type), except
-Show and Read, which really behave differently for
-the newtype and its representation.
+ k :: T -> T
+ k (MkT [t::a]) = MkT t3
+ where
+ t3::[a] = [t,t,t]
+
+Here, the pattern type signature (t::a) mentions a lexical type
+variable that is not already in scope. Indeed, it cannot already be in scope,
+because it is bound by the pattern match. GHC's rule is that in this situation
+(and only then), a pattern type signature can mention a type variable that is
+not already in scope; the effect is to bring it into scope, standing for the
+existentially-bound type variable.
+
+
+If this seems a little odd, we think so too. But we must have
+some way to bring such type variables into scope, else we
+could not name existentially-bound type variables in subequent type signatures.
+
+
+This is (now) the only situation in which a pattern type
+signature is allowed to mention a lexical variable that is not already in
+scope.
+For example, both f and g would be
+illegal if a was not already in scope.
+
+
- A more precise specification
+
+
+Class and instance declarations
-GHC now allows stand-alone deriving declarations:
-
-
-
- data Foo = Bar Int | Baz String
- deriving Eq for Foo
-
+The type variables in the head of a class or instance declaration
+scope over the methods defined in the where part. For example:
-Deriving instances of multi-parameter type classes for newtypes is
-also allowed:
- newtype Foo a = MkFoo (State Int a)
+ class C a where
+ op :: [a] -> a
- deriving (MonadState Int) for Foo
+ op xs = let ys::[a]
+ ys = reverse xs
+ in
+ head ys
-
-
+
+
Generalised typing of mutually recursive bindings
@@ -4110,6 +4064,57 @@ pattern binding must have the same context. For example, this is fine:
+
+Overloaded string literals
+
+
+
+GHC supports overloaded string literals. Normally a
+string literal has type String, but with overloaded string
+literals enabled (with -foverloaded-strings)
+ a string literal has type (IsString a) => a.
+
+
+This means that the usual string syntax can be used, e.g., for packed strings
+and other variations of string like types. String literals behave very much
+like integer literals, i.e., they can be used in both expressions and patterns.
+If used in a pattern the literal with be replaced by an equality test, in the same
+way as an integer literal is.
+
+
+The class IsString is defined as:
+
+class IsString a where
+ fromString :: String -> a
+
+And the only predefined instance is the obvious one to make strings work as usual:
+
+instance IsString [Char] where
+ fromString cs = cs
+
+
+
+A small example:
+
+newtype MyString = MyString String deriving (Eq, Show)
+instance IsString MyString where
+ fromString = MyString
+
+greet :: MyString -> MyString
+greet "hello" = "world"
+greet other = other
+
+main = do
+ print $ greet "hello"
+ print $ greet "fool"
+
+
+
+Note that deriving Eq is necessary for the pattern matching
+to work since it gets translated into an equality comparison.
+
+
+
@@ -4221,6 +4226,14 @@ Tim Sheard is going to expand it.)
(It would make sense to do so, but it's hard to implement.)
+
+ Furthermore, you can only run a function at compile time if it is imported
+ from another module that is not part of a mutually-recursive group of modules
+ that includes the module currently being compiled. For example, when compiling module A,
+ you can only run Template Haskell functions imported from B if B does not import A (directly or indirectly).
+ The reason should be clear: to run B we must compile and run A, but we are currently type-checking A.
+
+
The flag -ddump-splices shows the expansion of all top-level splices as they happen.
@@ -5953,12 +5966,6 @@ The following are good consumers:
- length
-
-
-
-
-++ (on its first argument)