X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=0ca2a5370abc302826e2843531e1eb3ffccf92b3;hb=fdcf1ffec106b17928d0dfabad4ee7c851500cd2;hp=5339c4323f710fd7589811526e4324c480fe3be3;hpb=c949e1a9af96cd5241d8cfc74fe3c622258edd7e;p=ghc-hetmet.git
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index 5339c43..0ca2a53 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -905,6 +905,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.
+
+
+
@@ -3198,7 +3230,27 @@ 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.
+
+
Lexically scoped type variables
@@ -3216,7 +3268,7 @@ f xs = ys ++ ys
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 y.
+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.
@@ -3252,8 +3304,6 @@ A lexically scoped type variable can be bound by:
A pattern type signature ()
Class and instance declarations ()
-In addition, GHC supports result type signatures (), although they never bind type variables.
In Haskell, a programmer-written type signature is implicitly quantifed over
@@ -3352,6 +3402,9 @@ illegal if a was not already in scope.
+
+
+
Class and instance declarations
@@ -3750,7 +3805,13 @@ for these Terms:
These and many other examples are given in papers by Hongwei Xi, and Tim Sheard.
- The extensions to GHC are these:
+
+The rest of this section outlines the extensions to GHC that support GADTs.
+It is far from comprehensive, but the design closely follows that described in
+the paper Simple
+unification-based type inference for GADTs,
+which appeared in ICFP 2006.
Data type declarations have a 'where' form, as exemplified above. The type signature of
@@ -3842,8 +3903,8 @@ 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
+ Nothing1 :: Maybe1 a ;
+ Just1 :: a -> Maybe1 a
} deriving( Eq, Ord )
data Maybe2 a = Nothing2 | Just2 a
@@ -3893,19 +3954,26 @@ the result type of the case expression. Hence the addition <
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.
@@ -5994,7 +6062,7 @@ r)
GHCziBase.ZMZN GHCziBase.Char -> GHCziBase.ZMZN GHCziBase.Cha
r) ->
tpl2})
- (%note "foo"
+ (%note "bar"
eta);
@@ -6096,9 +6164,6 @@ that it is well typed.
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.