X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=6f54d1e0c2f09bb7f17f0bc134cf593e0d3e8a55;hb=646ca6ffb55b1a9ee4c71e8573d87629dc7a4989;hp=de115ab82a0bad3623f096752ff0127d4b7233fd;hpb=64c630df5bf31f882dbbc62ec8ff75b6480a5f4d;p=ghc-hetmet.git
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index de115ab..6f54d1e 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -106,9 +106,7 @@ documentation describes all the libraries that come with GHC.
This option enables the language extension defined in the
- Haskell 98 Foreign Function Interface Addendum plus deprecated
- syntax of previous versions of the FFI for backwards
- compatibility.
+ Haskell 98 Foreign Function Interface Addendum.
New reserved words: foreign.
@@ -116,10 +114,10 @@ documentation describes all the libraries that come with GHC.
- ,:
+ ,:
- These two flags control how generalisation is done in
+ These two flags control how generalisation is done.
See .
@@ -905,6 +903,38 @@ fromInteger :: Integer -> Bool -> Bool
you should be all right.
+
+
+Postfix operators
+
+
+GHC allows a small extension to the syntax of left operator sections, which
+allows you to define postfix operators. The extension is this: the left section
+
+ (e !)
+
+is equivalent (from the point of view of both type checking and execution) to the expression
+
+ ((!) e)
+
+(for any expression e and operator (!).
+The strict Haskell 98 interpretation is that the section is equivalent to
+
+ (\y -> (!) e y)
+
+That is, the operator must be a function of two arguments. GHC allows it to
+take only one argument, and that in turn allows you to write the function
+postfix.
+
+Since this extension goes beyond Haskell 98, it should really be enabled
+by a flag; but in fact it is enabled all the time. (No Haskell 98 programs
+change their behaviour, of course.)
+
+The extension does not extend to the left-hand side of function
+definitions; you must define such a function in prefix form.
+
+
+
@@ -1279,7 +1309,7 @@ universal quantification earlier.
-
+Record Constructors
@@ -1331,20 +1361,6 @@ main = do
display (inc (inc counterB)) -- prints "##"
-In GADT declarations (see ), the explicit
-forall may be omitted. For example, we can express
-the same Counter a using GADT:
-
-
-data Counter a where
- NewCounter { _this :: self
- , _inc :: self -> self
- , _display :: self -> IO ()
- , tag :: a
- }
- :: Counter a
-
-
At the moment, record update syntax is only supported for Haskell 98 data types,
so the following function does not work:
@@ -1485,7 +1501,7 @@ are convincing reasons to change it.
You can't use deriving to define instances of a
data type with existentially quantified data constructors.
-Reason: in most cases it would not make sense. For example:#
+Reason: in most cases it would not make sense. For example:;
data T = forall a. MkT [a] deriving( Eq )
@@ -1513,6 +1529,315 @@ declarations. Define your own instances!
+
+
+
+Declaring data types with explicit constructor signatures
+
+GHC allows you to declare an algebraic data type by
+giving the type signatures of constructors explicitly. For example:
+
+ data Maybe a where
+ Nothing :: Maybe a
+ Just :: a -> Maybe a
+
+The form is called a "GADT-style declaration"
+because Generalised Algebraic Data Types, described in ,
+can only be declared using this form.
+Notice that GADT-style syntax generalises existential types ().
+For example, these two declarations are equivalent:
+
+ data Foo = forall a. MkFoo a (a -> Bool)
+ data Foo' where { MKFoo :: a -> (a->Bool) -> Foo' }
+
+
+Any data type that can be declared in standard Haskell-98 syntax
+can also be declared using GADT-style syntax.
+The choice is largely stylistic, but GADT-style declarations differ in one important respect:
+they treat class constraints on the data constructors differently.
+Specifically, if the constructor is given a type-class context, that
+context is made available by pattern matching. For example:
+
+ data Set a where
+ MkSet :: Eq a => [a] -> Set a
+
+ makeSet :: Eq a => [a] -> Set a
+ makeSet xs = MkSet (nub xs)
+
+ insert :: a -> Set a -> Set a
+ insert a (MkSet as) | a `elem` as = MkSet as
+ | otherwise = MkSet (a:as)
+
+A use of MkSet as a constructor (e.g. in the definition of makeSet)
+gives rise to a (Eq a)
+constraint, as you would expect. The new feature is that pattern-matching on MkSet
+(as in the definition of insert) makes available an (Eq a)
+context. In implementation terms, the MkSet constructor has a hidden field that stores
+the (Eq a) dictionary that is passed to MkSet; so
+when pattern-matching that dictionary becomes available for the right-hand side of the match.
+In the example, the equality dictionary is used to satisfy the equality constraint
+generated by the call to elem, so that the type of
+insert itself has no Eq constraint.
+
+This behaviour contrasts with Haskell 98's peculiar treament of
+contexts on a data type declaration (Section 4.2.1 of the Haskell 98 Report).
+In Haskell 98 the defintion
+
+ data Eq a => Set' a = MkSet' [a]
+
+gives MkSet' the same type as MkSet above. But instead of
+making available an (Eq a) constraint, pattern-matching
+on MkSet'requires an (Eq a) constraint!
+GHC faithfully implements this behaviour, odd though it is. But for GADT-style declarations,
+GHC's behaviour is much more useful, as well as much more intuitive.
+
+For example, a possible application of GHC's behaviour is to reify dictionaries:
+
+ data NumInst a where
+ MkNumInst :: Num a => NumInst a
+
+ intInst :: NumInst Int
+ intInst = MkNumInst
+
+ plus :: NumInst a -> a -> a -> a
+ plus MkNumInst p q = p + q
+
+Here, a value of type NumInst a is equivalent
+to an explicit (Num a) dictionary.
+
+
+
+The rest of this section gives further details about GADT-style data
+type declarations.
+
+
+
+The result type of each data constructor must begin with the type constructor being defined.
+If the result type of all constructors
+has the form T a1 ... an, where a1 ... an
+are distinct type variables, then the data type is ordinary;
+otherwise is a generalised data type ().
+
+
+
+The type signature of
+each constructor is independent, and is implicitly universally quantified as usual.
+Different constructors may have different universally-quantified type variables
+and different type-class constraints.
+For example, this is fine:
+
+ data T a where
+ T1 :: Eq b => b -> T b
+ T2 :: (Show c, Ix c) => c -> [c] -> T c
+
+
+
+
+Unlike a Haskell-98-style
+data type declaration, the type variable(s) in the "data Set a where" header
+have no scope. Indeed, one can write a kind signature instead:
+
+ data Set :: * -> * where ...
+
+or even a mixture of the two:
+
+ data Foo a :: (* -> *) -> * where ...
+
+The type variables (if given) may be explicitly kinded, so we could also write the header for Foo
+like this:
+
+ data Foo a (b :: * -> *) where ...
+
+
+
+
+
+You can use strictness annotations, in the obvious places
+in the constructor type:
+
+ data Term a where
+ Lit :: !Int -> Term Int
+ If :: Term Bool -> !(Term a) -> !(Term a) -> Term a
+ Pair :: Term a -> Term b -> Term (a,b)
+
+
+
+
+You can use a deriving clause on a GADT-style data type
+declaration. For example, these two declarations are equivalent
+
+ data Maybe1 a where {
+ Nothing1 :: Maybe1 a ;
+ Just1 :: a -> Maybe1 a
+ } deriving( Eq, Ord )
+
+ data Maybe2 a = Nothing2 | Just2 a
+ deriving( Eq, Ord )
+
+
+
+
+You can use record syntax on a GADT-style data type declaration:
+
+
+ data Person where
+ Adult { name :: String, children :: [Person] } :: Person
+ Child { name :: String } :: Person
+
+As usual, for every constructor that has a field f, the type of
+field f must be the same (modulo alpha conversion).
+
+
+At the moment, record updates are not yet possible with GADT-style declarations,
+so support is limited to record construction, selection and pattern matching.
+For exmaple
+
+ aPerson = Adult { name = "Fred", children = [] }
+
+ shortName :: Person -> Bool
+ hasChildren (Adult { children = kids }) = not (null kids)
+ hasChildren (Child {}) = False
+
+
+
+
+As in the case of existentials declared using the Haskell-98-like record syntax
+(),
+record-selector functions are generated only for those fields that have well-typed
+selectors.
+Here is the example of that section, in GADT-style syntax:
+
+data Counter a where
+ NewCounter { _this :: self
+ , _inc :: self -> self
+ , _display :: self -> IO ()
+ , tag :: a
+ }
+ :: Counter a
+
+As before, only one selector function is generated here, that for tag.
+Nevertheless, you can still use all the field names in pattern matching and record construction.
+
+
+
+
+
+Generalised Algebraic Data Types (GADTs)
+
+Generalised Algebraic Data Types generalise ordinary algebraic data types
+by allowing constructors to have richer return types. Here is an example:
+
+ data Term a where
+ Lit :: Int -> Term Int
+ Succ :: Term Int -> Term Int
+ IsZero :: Term Int -> Term Bool
+ If :: Term Bool -> Term a -> Term a -> Term a
+ Pair :: Term a -> Term b -> Term (a,b)
+
+Notice that the return type of the constructors is not always Term a, as is the
+case with ordinary data types. This generality allows us to
+write a well-typed eval function
+for these Terms:
+
+ eval :: Term a -> a
+ eval (Lit i) = i
+ eval (Succ t) = 1 + eval t
+ eval (IsZero t) = eval t == 0
+ eval (If b e1 e2) = if eval b then eval e1 else eval e2
+ eval (Pair e1 e2) = (eval e1, eval e2)
+
+The key point about GADTs is that pattern matching causes type refinement.
+For example, in the right hand side of the equation
+
+ eval :: Term a -> a
+ eval (Lit i) = ...
+
+the type a is refined to Int. That's the whole point!
+A precise specification of the type rules is beyond what this user manual aspires to,
+but the design closely follows that described in
+the paper Simple
+unification-based type inference for GADTs,
+(ICFP 2006).
+The general principle is this: type refinement is only carried out
+based on user-supplied type annotations.
+So if no type signature is supplied for eval, no type refinement happens,
+and lots of obscure error messages will
+occur. However, the refinement is quite general. For example, if we had:
+
+ eval :: Term a -> a -> a
+ eval (Lit i) j = i+j
+
+the pattern match causes the type a to be refined to Int (because of the type
+of the constructor Lit), and that refinement also applies to the type of j, and
+the result type of the case expression. Hence the addition i+j is legal.
+
+
+These and many other examples are given in papers by Hongwei Xi, and
+Tim Sheard. There is a longer introduction
+on the wiki,
+and Ralf Hinze's
+Fun with phantom types also has a number of examples. Note that papers
+may use different notation to that implemented in GHC.
+
+
+The rest of this section outlines the extensions to GHC that support GADTs.
+
+
+A GADT can only be declared using GADT-style syntax ();
+the old Haskell-98 syntax for data declarations always declares an ordinary data type.
+The result type of each constructor must begin with the type constructor being defined,
+but for a GADT the arguments to the type constructor can be arbitrary monotypes.
+For example, in the Term data
+type above, the type of each constructor must end with Term ty, but
+the ty may not be a type variable (e.g. the Lit
+constructor).
+
+
+
+You cannot use a deriving clause for a GADT; only for
+an ordianary data type.
+
+
+
+As mentioned in , record syntax is supported.
+For example:
+
+ data Term a where
+ Lit { val :: Int } :: Term Int
+ Succ { num :: Term Int } :: Term Int
+ Pred { num :: Term Int } :: Term Int
+ IsZero { arg :: Term Int } :: Term Bool
+ Pair { arg1 :: Term a
+ , arg2 :: Term b
+ } :: Term (a,b)
+ If { cnd :: Term Bool
+ , tru :: Term a
+ , fls :: Term a
+ } :: Term a
+
+However, for GADTs there is the following additional constraint:
+every constructor that has a field f must have
+the same result type (modulo alpha conversion)
+Hence, in the above example, we cannot merge the num
+and arg fields above into a
+single name. Although their field types are both Term Int,
+their selector functions actually have different types:
+
+
+ num :: Term Int -> Term Int
+ arg :: Term Bool -> Term Int
+
+
+
+
+
+
+
+
+
+
+
@@ -2194,8 +2519,20 @@ some other constraint. But if the instance declaration was compiled with
check for that declaration.
-All this makes it possible for a library author to design a library that relies on
-overlapping instances without the library client having to know.
+These rules make it possible for a library author to design a library that relies on
+overlapping instances without the library client having to know.
+
+
+If an instance declaration is compiled without
+,
+then that instance can never be overlapped. This could perhaps be
+inconvenient. Perhaps the rule should instead say that the
+overlapping instance declaration should be compiled in
+this way, rather than the overlapped one. Perhaps overlap
+at a usage site should be permitted regardless of how the instance declarations
+are compiled, if the flag is
+used at the usage site. (Mind you, the exact usage site can occasionally be
+hard to pin down.) We are interested to receive feedback on these points.
The flag implies the
flag, but not vice versa.
@@ -3186,228 +3523,103 @@ for rank-2 types.
-
+
+Impredicative polymorphism
+
+GHC supports impredicative polymorphism. This means
+that you can call a polymorphic function at a polymorphic type, and
+parameterise data structures over polymorphic types. For example:
+
+ f :: Maybe (forall a. [a] -> [a]) -> Maybe ([Int], [Char])
+ f (Just g) = Just (g [3], g "hello")
+ f Nothing = Nothing
+
+Notice here that the Maybe type is parameterised by the
+polymorphic type (forall a. [a] ->
+[a]).
+
+The technical details of this extension are described in the paper
+Boxy types:
+type inference for higher-rank types and impredicativity,
+which appeared at ICFP 2006.
+
+
-Scoped type variables
+<title>Lexically scoped type variables
-A lexically scoped type variable can be bound by:
-
-A declaration type signature ()
-A pattern type signature ()
-A result type signature ()
-
-For example:
+GHC supports lexically scoped type variables, without
+which some type signatures are simply impossible to write. For example:
-f (xs::[a]) = ys ++ ys
- where
- ys :: [a]
- ys = reverse xs
+f :: forall a. [a] -> [a]
+f xs = ys ++ ys
+ where
+ ys :: [a]
+ ys = reverse xs
-The pattern (xs::[a]) includes a type signature for xs.
-This brings the type variable a into scope; it scopes over
-all the patterns and right hand sides for this equation for f.
-In particular, it is in scope at the type signature for y.
-
-
-
-At ordinary type signatures, such as that for ys, any type variables
-mentioned in the type signature that are not in scope are
-implicitly universally quantified. (If there are no type variables in
-scope, all type variables mentioned in the signature are universally
-quantified, which is just as in Haskell 98.) In this case, since a
-is in scope, it is not universally quantified, so the type of ys is
-the same as that of xs. In Haskell 98 it is not possible to declare
+The type signature for f brings the type variable a into scope; it scopes over
+the entire definition of f.
+In particular, it is in scope at the type signature for ys.
+In Haskell 98 it is not possible to declare
a type for ys; a major benefit of scoped type variables is that
it becomes possible to do so.
-
-
-Scoped type variables are implemented in both GHC and Hugs. Where the
-implementations differ from the specification below, those differences
-are noted.
-
-
-
-So much for the basic idea. Here are the details.
+Lexically-scoped type variables are enabled by
+.
+Note: GHC 6.6 contains substantial changes to the way that scoped type
+variables work, compared to earlier releases. Read this section
+carefully!
-What a scoped type variable means
-
-A lexically-scoped type variable is simply
-the name for a type. The restriction it expresses is that all occurrences
-of the same name mean the same type. For example:
-
- f :: [Int] -> Int -> Int
- f (xs::[a]) (y::a) = (head xs + y) :: a
-
-The pattern type signatures on the left hand side of
-f express the fact that xs
-must be a list of things of some type a; and that y
-must have this same type. The type signature on the expression (head xs)
-specifies that this expression must have the same type a.
-There is no requirement that the type named by "a" is
-in fact a type variable. Indeed, in this case, the type named by "a" is
-Int. (This is a slight liberalisation from the original rather complex
-rules, which specified that a pattern-bound type variable should be universally quantified.)
-For example, all of these are legal:
-
-
- t (x::a) (y::a) = x+y*2
-
- f (x::a) (y::b) = [x,y] -- a unifies with b
-
- g (x::a) = x + 1::Int -- a unifies with Int
-
- h x = let k (y::a) = [x,y] -- a is free in the
- in k x -- environment
-
- k (x::a) True = ... -- a unifies with Int
- k (x::Int) False = ...
-
- w :: [b] -> [b]
- w (x::a) = x -- a unifies with [b]
-
-
-
-
-
-Scope and implicit quantification
-
-
+Overview
+The design follows the following principles
-
-
-
-All the type variables mentioned in a pattern,
-that are not already in scope,
-are brought into scope by the pattern. We describe this set as
-the type variables bound by the pattern.
-For example:
-
- f (x::a) = let g (y::(a,b)) = fst y
- in
- g (x,True)
-
-The pattern (x::a) brings the type variable
-a into scope, as well as the term
-variable x. The pattern (y::(a,b))
-contains an occurrence of the already-in-scope type variable a,
-and brings into scope the type variable b.
-
-
-
-
-
-The type variable(s) bound by the pattern have the same scope
-as the term variable(s) bound by the pattern. For example:
-
- let
- f (x::a) = <...rhs of f...>
- (p::b, q::b) = (1,2)
- in <...body of let...>
-
-Here, the type variable a scopes over the right hand side of f,
-just like x does; while the type variable b scopes over the
-body of the let, and all the other definitions in the let,
-just like p and q do.
-Indeed, the newly bound type variables also scope over any ordinary, separate
-type signatures in the let group.
-
-
-
-
-
-
-The type variables bound by the pattern may be
-mentioned in ordinary type signatures or pattern
-type signatures anywhere within their scope.
-
-
-
-
-
-
- In ordinary type signatures, any type variable mentioned in the
-signature that is in scope is not universally quantified.
-
-
-
-
-
-
-
- Ordinary type signatures do not bring any new type variables
-into scope (except in the type signature itself!). So this is illegal:
-
-
- f :: a -> a
- f x = x::a
-
-
-It's illegal because a is not in scope in the body of f,
-so the ordinary signature x::a is equivalent to x::forall a.a;
-and that is an incorrect typing.
-
+A scoped type variable stands for a type variable, and not for
+a type. (This is a change from GHC's earlier
+design.)
+Furthermore, distinct lexical type variables stand for distinct
+type variables. This means that every programmer-written type signature
+(includin one that contains free scoped type variables) denotes a
+rigid type; that is, the type is fully known to the type
+checker, and no inference is involved.
+Lexical type variables may be alpha-renamed freely, without
+changing the program.
+
-
-
-
-The pattern type signature is a monotype:
-
-
+A lexically scoped type variable can be bound by:
-
-A pattern type signature cannot contain any explicit forall quantification.
-
-
-
-The type variables bound by a pattern type signature can only be instantiated to monotypes,
-not to type schemes.
-
-
-
-There is no implicit universal quantification on pattern type signatures (in contrast to
-ordinary type signatures).
-
-
+A declaration type signature ()
+An expression type signature ()
+A pattern type signature ()
+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:
-
-
+In Haskell, a programmer-written type signature is implicitly quantifed over
+its free type variables (Section
+4.1.2
+of the Haskel Report).
+Lexically scoped type variables affect this implicit quantification rules
+as follows: any type variable that is in scope is not universally
+quantified. For example, if type variable a is in scope,
+then
- class C a where
- op :: [a] -> a
-
- op xs = let ys::[a]
- ys = reverse xs
- in
- head ys
+ (e :: a -> a) means (e :: a -> a)
+ (e :: b -> b) means (e :: forall b. b->b)
+ (e :: a -> b) means (e :: forall b. a->b)
-
-
-(Not implemented in Hugs yet, Dec 98).
-
-
-
-
+
Declaration type signaturesA declaration type signature that has explicit
@@ -3419,195 +3631,160 @@ type variables, in the definition of the named function(s). For example:
f (x:xs) = xs ++ [ x :: a ]
The "forall a" brings "a" into scope in
-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.
-
-
-
-
-Where a pattern type signature can occur
-
-
-A pattern type signature can occur in any pattern. For example:
-
-
-
-
-A pattern type signature can be on an arbitrary sub-pattern, not
-just on a variable:
-
-
-
- f ((x,y)::(a,b)) = (y,x) :: (b,a)
-
-
-
-
-
-
-
-
- Pattern type signatures, including the result part, can be used
-in lambda abstractions:
-
+the definition of "f".
+
+This only happens if the quantification in f's type
+signature is explicit. For example:
- (\ (x::a, y) :: a -> x)
+ 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.
-
-
+
-
- Pattern type signatures, including the result part, can be used
-in case expressions:
+
+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:
- case e of { ((x::a, y) :: (a,b)) -> x }
+ f = runST ( (op >>= \(x :: STRef s Int) -> g x) :: forall s. ST s Bool )
-
-Note that the -> symbol in a case alternative
-leads to difficulties when parsing a type signature in the pattern: in
-the absence of the extra parentheses in the example above, the parser
-would try to interpret the -> as a function
-arrow and give a parse error later.
-
+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
-To avoid ambiguity, the type after the “::” in a result
-pattern signature on a lambda or case must be atomic (i.e. a single
-token or a parenthesised type of some sort). To see why,
-consider how one would parse this:
-
-
+A type signature may occur in any pattern; this is a pattern type
+signature.
+For example:
- \ x :: a -> b -> x
+ -- 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.
-
-
-
-
- Pattern type signatures can bind existential type variables.
-For example:
-
-
+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]
- f :: T -> T
- f (MkT [t::a]) = MkT t3
+ 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.
-
-
-
-
-
-Pattern type signatures
-can be used in pattern bindings:
-
-
- f x = let (y, z::a) = x in ...
- f1 x = let (y, z::Int) = x in ...
- f2 (x::(Int,a)) = let (y, z::a) = x in ...
- f3 :: (b->b) = \x -> x
-
-
-In all such cases, the binding is not generalised over the pattern-bound
-type variables. Thus f3 is monomorphic; f3
-has type b -> b for some type b,
-and notforall b. b -> b.
-In contrast, the binding
-
- f4 :: b->b
- f4 = \x -> x
-
-makes a polymorphic function, but b is not in scope anywhere
-in f4's scope.
-
+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.
-Pattern type signatures are completely orthogonal to ordinary, separate
-type signatures. The two can be used independently or together.
+
+
+
+
+Class and instance declarations
-Result type signatures are not yet implemented in Hugs.
-
+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
+
+
@@ -3774,16 +3951,19 @@ declaration (after expansion of any type synonyms)
where
- The type t is an arbitrary type
+ 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 vk+1...vn are type variables which do not occur in
- t, and
+ The k is chosen so that ci (T v1...vk) is well-kinded.
- 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 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,
@@ -3796,13 +3976,8 @@ where
Then, for each ci, the derived instance
declaration is:
- instance ci (t vk+1...v) => ci (T v1...vp)
+ instance ci t => ci (T v1...vk)
-where p is chosen so that T v1...vp is of the
-right kind for the last parameter of class Ci.
-
-
-
As an example which does not work, consider
newtype NonMonad m s = NonMonad (State s m s) deriving Monad
@@ -3845,6 +4020,33 @@ the standard method is used or the one described here.)
+
+Stand-alone deriving declarations
+
+
+GHC now allows stand-alone deriving declarations:
+
+
+
+ data Foo = Bar Int | Baz String
+
+ deriving Eq for Foo
+
+
+Deriving instances of multi-parameter type classes for newtypes is
+also allowed:
+
+
+ newtype Foo a = MkFoo (State Int a)
+
+ deriving (MonadState Int) for Foo
+
+
+
+
+
+
+
Generalised typing of mutually recursive bindings
@@ -3911,190 +4113,31 @@ pattern binding must have the same context. For example, this is fine:
-
-
-
-Generalised Algebraic Data Types
-
-Generalised Algebraic Data Types (GADTs) generalise ordinary algebraic data types by allowing you
-to give the type signatures of constructors explicitly. For example:
-
- data Term a where
- Lit :: Int -> Term Int
- Succ :: Term Int -> Term Int
- IsZero :: Term Int -> Term Bool
- If :: Term Bool -> Term a -> Term a -> Term a
- Pair :: Term a -> Term b -> Term (a,b)
-
-Notice that the return type of the constructors is not always Term a, as is the
-case with ordinary vanilla data types. Now we can write a well-typed eval function
-for these Terms:
-
- eval :: Term a -> a
- eval (Lit i) = i
- eval (Succ t) = 1 + eval t
- eval (IsZero t) = eval t == 0
- eval (If b e1 e2) = if eval b then eval e1 else eval e2
- eval (Pair e1 e2) = (eval e1, eval e2)
-
-These and many other examples are given in papers by Hongwei Xi, and Tim Sheard.
-
- The extensions to GHC are these:
-
-
- Data type declarations have a 'where' form, as exemplified above. The type signature of
-each constructor is independent, and is implicitly universally quantified as usual. Unlike a normal
-Haskell data type declaration, the type variable(s) in the "data Term a where" header
-have no scope. Indeed, one can write a kind signature instead:
-
- data Term :: * -> * where ...
-
-or even a mixture of the two:
-
- data Foo a :: (* -> *) -> * where ...
-
-The type variables (if given) may be explicitly kinded, so we could also write the header for Foo
-like this:
-
- data Foo a (b :: * -> *) where ...
-
-
-
-
-There are no restrictions on the type of the data constructor, except that the result
-type must begin with the type constructor being defined. For example, in the Term data
-type above, the type of each constructor must end with ... -> Term ....
-
-
-
-You can use record syntax on a GADT-style data type declaration:
-
-
- data Term a where
- Lit { val :: Int } :: Term Int
- Succ { num :: Term Int } :: Term Int
- Pred { num :: Term Int } :: Term Int
- IsZero { arg :: Term Int } :: Term Bool
- Pair { arg1 :: Term a
- , arg2 :: Term b
- } :: Term (a,b)
- If { cnd :: Term Bool
- , tru :: Term a
- , fls :: Term a
- } :: Term a
-
-For every constructor that has a field f, (a) the type of
-field f must be the same; and (b) the
-result type of the constructor must be the same; both modulo alpha conversion.
-Hence, in our example, we cannot merge the num and arg
-fields above into a
-single name. Although their field types are both Term Int,
-their selector functions actually have different types:
-
-
- num :: Term Int -> Term Int
- arg :: Term Bool -> Term Int
-
-
-At the moment, record updates are not yet possible with GADT, so support is
-limited to record construction, selection and pattern matching:
-
-
- someTerm :: Term Bool
- someTerm = IsZero { arg = Succ { num = Lit { val = 0 } } }
-
- eval :: Term a -> a
- eval Lit { val = i } = i
- eval Succ { num = t } = eval t + 1
- eval Pred { num = t } = eval t - 1
- eval IsZero { arg = t } = eval t == 0
- eval Pair { arg1 = t1, arg2 = t2 } = (eval t1, eval t2)
- eval t@If{} = if eval (cnd t) then eval (tru t) else eval (fls t)
-
-
-
-
-
-You can use strictness annotations, in the obvious places
-in the constructor type:
-
- data Term a where
- Lit :: !Int -> Term Int
- If :: Term Bool -> !(Term a) -> !(Term a) -> Term a
- Pair :: Term a -> Term b -> Term (a,b)
-
-
-
-
-You can use a deriving clause on a GADT-style data type
-declaration, but only if the data type could also have been declared in
-Haskell-98 syntax. For example, these two declarations are equivalent
-
- data Maybe1 a where {
- Nothing1 :: Maybe a ;
- Just1 :: a -> Maybe a
- } deriving( Eq, Ord )
-
- data Maybe2 a = Nothing2 | Just2 a
- deriving( Eq, Ord )
-
-This simply allows you to declare a vanilla Haskell-98 data type using the
-where form without losing the deriving clause.
-
-
-
-Pattern matching causes type refinement. For example, in the right hand side of the equation
-
- eval :: Term a -> a
- eval (Lit i) = ...
-
-the type a is refined to Int. (That's the whole point!)
-A precise specification of the type rules is beyond what this user manual aspires to, but there is a paper
-about the ideas: "Wobbly types: practical type inference for generalised algebraic data types", on Simon PJ's home page.
-
- The general principle is this: type refinement is only carried out based on user-supplied type annotations.
-So if no type signature is supplied for eval, no type refinement happens, and lots of obscure error messages will
-occur. However, the refinement is quite general. For example, if we had:
-
- eval :: Term a -> a -> a
- eval (Lit i) j = i+j
-
-the pattern match causes the type a to be refined to Int (because of the type
-of the constructor Lit, and that refinement also applies to the type of j, and
-the result type of the case expression. Hence the addition i+j is legal.
-
-
-
-
-
-Notice that GADTs generalise existential types. For example, these two declarations are equivalent:
-
- data T a = forall b. MkT b (b->a)
- data T' a where { MKT :: b -> (b->a) -> T' a }
-
-
-
-
-
-
Template Haskell
-Template Haskell allows you to do compile-time meta-programming in Haskell. There is a "home page" for
-Template Haskell at
-http://www.haskell.org/th/, while
-the background to
+Template Haskell allows you to do compile-time meta-programming in
+Haskell.
+The background to
the main technical innovations is discussed in "
Template Meta-programming for Haskell" (Proc Haskell Workshop 2002).
-The details of the Template Haskell design are still in flux. Make sure you
-consult the online library reference material
+
+
+There is a Wiki page about
+Template Haskell at
+http://www.haskell.org/th/, and that is the best place to look for
+further details.
+You may also
+consult the online
+Haskell library reference material
(search for the type ExpQ).
[Temporary: many changes to the original design are described in
"http://research.microsoft.com/~simonpj/tmp/notes2.ps".
-Not all of these changes are in GHC 6.2.]
+Not all of these changes are in GHC 6.6.]
The first example from that paper is set out below as a worked example to help get you started.
@@ -4804,8 +4847,8 @@ Because the preprocessor targets Haskell (rather than Core),
GHC supports an extension of pattern matching called bang
patterns. Bang patterns are under consideration for Haskell Prime.
The the
-Haskell prime feature description contains more discussion and examples
+url="http://hackage.haskell.org/trac/haskell-prime/wiki/BangPatterns">Haskell
+prime feature description contains more discussion and examples
than the material below.
@@ -4882,7 +4925,7 @@ f !x = 3
Is this a definition of the infix function "(!)",
or of the "f" with a bang pattern? GHC resolves this
-ambiguity inf favour of the latter. If you want to define
+ambiguity in favour of the latter. If you want to define
(!) with bang-patterns enabled, you have to do so using
prefix notation:
@@ -6183,7 +6226,7 @@ r)
GHCziBase.ZMZN GHCziBase.Char -> GHCziBase.ZMZN GHCziBase.Cha
r) ->
tpl2})
- (%note "foo"
+ (%note "bar"
eta);
@@ -6205,6 +6248,22 @@ r) ->
described in this section. All are exported by
GHC.Exts.
+The <literal>seq</literal> function
+
+The function seq is as described in the Haskell98 Report.
+
+ seq :: a -> b -> b
+
+It evaluates its first argument to head normal form, and then returns its
+second argument as the result. The reason that it is documented here is
+that, despite seq's polymorphism, its
+second argument can have an unboxed type, or
+can be an unboxed tuple; for example (seq x 4#)
+or (seq x (# p,q #)). This requires b
+to be instantiated to an unboxed type, which is not usually allowed.
+
+
+
The <literal>inline</literal> function
The inline function is somewhat experimental.
@@ -6263,6 +6322,11 @@ If lazy were not lazy, par would
look strict in y which would defeat the whole
purpose of par.
+
+Like seq, the argument of lazy can have
+an unboxed type.
+
+
The <literal>unsafeCoerce#</literal> function
@@ -6278,16 +6342,20 @@ It is generally used when you want to write a program that you know is
well-typed, but where Haskell's type system is not expressive enough to prove
that it is well typed.
+
+The argument to unsafeCoerce# can have unboxed types,
+although extremely bad things will happen if you coerce a boxed type
+to an unboxed type.
+
+
+
Generic classes
- (Note: support for generic classes is currently broken in
- GHC 5.02).
-
The ideas behind this extension are described in detail in "Derivable type classes",
Ralf Hinze and Simon Peyton Jones, Haskell Workshop, Montreal Sept 2000, pp94-105.
@@ -6559,7 +6627,7 @@ can be completely switched off by
-Monomorphic patteern bindings
+Monomorphic pattern bindings