X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=a1cf5c5f6ab203aff6bfa5174c4b0ce3ee82956a;hb=836cafeb3edd9c728fe4c86cf90229e1476ad14a;hp=a01dea4729f60d0a48f6d733ce882efdad1125ee;hpb=6ab0a2a07d93efc14f376c2cf5eb43836c6d1157;p=ghc-hetmet.git

diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index a01dea4..a1cf5c5 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -319,7 +319,7 @@ it is always correct!  It is also intended for processing into text.</para>
 <para> Indeed,
 the result of such processing is part of the description of the 
  <ulink
-      url="http://haskell.cs.yale.edu/ghc/docs/papers/core.ps.gz">External
+      url="http://www.haskell.org/ghc/docs/papers/core.ps.gz">External
 	 Core language</ulink>.
 So that document is a good place to look for a type-set version.
 We would be very happy if someone wanted to volunteer to produce an SGML
@@ -993,7 +993,7 @@ and improve termination (Section 3.2 of the paper).
 </para>
 
 <para>
-The web page: <ulink url="http://www.cse.ogi.edu/PacSoft/projects/rmb">http://www.cse.ogi.edu/PacSoft/projects/rmb</ulink>
+The web page: <ulink url="http://www.cse.ogi.edu/PacSoft/projects/rmb/">http://www.cse.ogi.edu/PacSoft/projects/rmb/</ulink>
 contains up to date information on recursive monadic bindings.
 </para>
 
@@ -2214,7 +2214,7 @@ the type <literal>a</literal> is refined to <literal>Int</literal>.  That's the
 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 <ulink
-url="http://research.microsoft.com/%7Esimonpj/papers/gadt/index.htm">Simple
+url="http://research.microsoft.com/%7Esimonpj/papers/gadt/">Simple
 unification-based type inference for GADTs</ulink>,
 (ICFP 2006).
 The general principle is this: <emphasis>type refinement is only carried out 
@@ -2233,7 +2233,7 @@ the result type of the <literal>case</literal> expression.  Hence the addition <
 <para>
 These and many other examples are given in papers by Hongwei Xi, and
 Tim Sheard. There is a longer introduction
-<ulink url="http://haskell.org/haskellwiki/GADT">on the wiki</ulink>,
+<ulink url="http://www.haskell.org/haskellwiki/GADT">on the wiki</ulink>,
 and Ralf Hinze's
 <ulink url="http://www.informatik.uni-bonn.de/~ralf/publications/With.pdf">Fun with phantom types</ulink> also has a number of examples. Note that papers
 may use different notation to that implemented in GHC.
@@ -2609,8 +2609,8 @@ the standard method is used or the one described here.)
 <para>
 This section, and the next one, documents GHC's type-class extensions.
 There's lots of background in the paper <ulink
-url="http://research.microsoft.com/~simonpj/Papers/type-class-design-space" >Type
-classes: exploring the design space</ulink > (Simon Peyton Jones, Mark
+url="http://research.microsoft.com/~simonpj/Papers/type-class-design-space/">Type
+classes: exploring the design space</ulink> (Simon Peyton Jones, Mark
 Jones, Erik Meijer).
 </para>
 <para>
@@ -2689,7 +2689,7 @@ class type variable, thus:
 The type of <literal>elem</literal> is illegal in Haskell 98, because it
 contains the constraint <literal>Eq a</literal>, constrains only the 
 class type variable (in this case <literal>a</literal>).
-GHC lifts this restriction.
+GHC lifts this restriction (flag <option>-XConstrainedClassMethods</option>).
 </para>
 
 
@@ -2701,7 +2701,7 @@ GHC lifts this restriction.
 </title>
 
 <para> Functional dependencies are implemented as described by Mark Jones
-in &ldquo;<ulink url="http://www.cse.ogi.edu/~mpj/pubs/fundeps.html">Type Classes with Functional Dependencies</ulink>&rdquo;, Mark P. Jones, 
+in &ldquo;<ulink url="http://citeseer.ist.psu.edu/jones00type.html">Type Classes with Functional Dependencies</ulink>&rdquo;, Mark P. Jones, 
 In Proceedings of the 9th European Symposium on Programming, 
 ESOP 2000, Berlin, Germany, March 2000, Springer-Verlag LNCS 1782,
 .
@@ -3036,7 +3036,7 @@ must be of the form <literal>C a</literal> where <literal>a</literal>
 is a type variable that occurs in the head.
 </para>
 <para>
-The <option>-fglasgow-exts</option> flag loosens these restrictions
+The <option>-XFlexibleInstances</option> flag loosens these restrictions
 considerably.  Firstly, multi-parameter type classes are permitted.  Secondly,
 the context and head of the instance declaration can each consist of arbitrary
 (well-kinded) assertions <literal>(C t1 ... tn)</literal> subject only to the
@@ -3401,7 +3401,7 @@ instance of <literal>Num</literal> <emphasis>or</emphasis> of <literal>IsString<
 </para></listitem>
 
 <listitem><para>
-The standard defaulting rule (<ulink url="http://haskell.org/onlinereport/decls.html#sect4.3.4">Haskell Report, Section 4.3.4</ulink>)
+The standard defaulting rule (<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.3.4">Haskell Report, Section 4.3.4</ulink>)
 is extended thus: defaulting applies when all the unresolved constraints involve standard classes
 <emphasis>or</emphasis> <literal>IsString</literal>; and at least one is a numeric class
 <emphasis>or</emphasis> <literal>IsString</literal>.
@@ -3442,7 +3442,7 @@ to work since it gets translated into an equality comparison.
 <sect2 id="type-restrictions">
 <title>Type signatures</title>
 
-<sect3><title>The context of a type signature</title>
+<sect3 id="flexible-contexts"><title>The context of a type signature</title>
 <para>
 Unlike Haskell 98, constraints in types do <emphasis>not</emphasis> have to be of
 the form <emphasis>(class type-variable)</emphasis> or
@@ -4078,9 +4078,18 @@ The function <literal>f3</literal> has a rank-3 type;
 it has rank-2 types on the left of a function arrow.
 </para>
 <para>
-GHC allows types of arbitrary rank; you can nest <literal>forall</literal>s
-arbitrarily deep in function arrows.   (GHC used to be restricted to rank 2, but
-that restriction has now been lifted.)
+GHC has three flags to control higher-rank types:
+<itemizedlist>
+<listitem><para>
+ <option>-XPolymorphicComponents</option>: data constructors (only) can have polymorphic argment types.
+</para></listitem>
+<listitem><para>
+ <option>-XRank2Types</option>: any function (including data constructors) can have a rank-2 type.
+</para></listitem>
+<listitem><para>
+ <option>-XRankNTypes</option>: any function (including data constructors) can have an arbitrary-rank type.
+That is,  you can nest <literal>forall</literal>s
+arbitrarily deep in function arrows.
 In particular, a forall-type (also called a "type scheme"),
 including an operational type class context, is legal:
 <itemizedlist>
@@ -4092,6 +4101,8 @@ field type signatures.</para> </listitem>
 <listitem> <para> As the type of an implicit parameter </para> </listitem>
 <listitem> <para> In a pattern type signature (see <xref linkend="scoped-type-variables"/>) </para> </listitem>
 </itemizedlist>
+</para></listitem>
+</itemizedlist>
 Of course <literal>forall</literal> becomes a keyword; you can't use <literal>forall</literal> as
 a type variable any more!
 </para>
@@ -4343,7 +4354,7 @@ Notice here that the <literal>Maybe</literal> type is parameterised by the
 [a])</literal>.
 </para>
 <para>The technical details of this extension are described in the paper
-<ulink url="http://research.microsoft.com/%7Esimonpj/papers/boxy">Boxy types:
+<ulink url="http://research.microsoft.com/%7Esimonpj/papers/boxy/">Boxy types:
 type inference for higher-rank types and impredicativity</ulink>,
 which appeared at ICFP 2006.  
 </para>
@@ -4406,7 +4417,7 @@ A <emphasis>lexically scoped type variable</emphasis> can be bound by:
 <para>
 In Haskell, a programmer-written type signature is implicitly quantified over
 its free type variables (<ulink
-url="http://haskell.org/onlinereport/decls.html#sect4.1.2">Section
+url="http://www.haskell.org/onlinereport/decls.html#sect4.1.2">Section
 4.1.2</ulink> 
 of the Haskel Report).
 Lexically scoped type variables affect this implicit quantification rules
@@ -4624,18 +4635,18 @@ scope over the methods defined in the <literal>where</literal> part.  For exampl
 The Haskell Report specifies that a group of bindings (at top level, or in a
 <literal>let</literal> or <literal>where</literal>) should be sorted into
 strongly-connected components, and then type-checked in dependency order
-(<ulink url="http://haskell.org/onlinereport/decls.html#sect4.5.1">Haskell
+(<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.1">Haskell
 Report, Section 4.5.1</ulink>).  
 As each group is type-checked, any binders of the group that
 have
 an explicit type signature are put in the type environment with the specified
 polymorphic type,
 and all others are monomorphic until the group is generalised 
-(<ulink url="http://haskell.org/onlinereport/decls.html#sect4.5.2">Haskell Report, Section 4.5.2</ulink>).
+(<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.2">Haskell Report, Section 4.5.2</ulink>).
 </para>
 
 <para>Following a suggestion of Mark Jones, in his paper
-<ulink url="http://www.cse.ogi.edu/~mpj/thih/">Typing Haskell in
+<ulink url="http://citeseer.ist.psu.edu/424440.html">Typing Haskell in
 Haskell</ulink>,
 GHC implements a more general scheme.  If <option>-XRelaxedPolyRec</option> is
 specified:
@@ -4696,7 +4707,7 @@ Currently, only the former are fully implemented, while we are still working
 on the latter.  As a result, the specification of the language extension is
 also still to some degree in flux.  Hence, a more detailed description of
 the language extension and its use is currently available
-from <ulink url="http://haskell.org/haskellwiki/GHC/Indexed_types">the Haskell
+from <ulink url="http://www.haskell.org/haskellwiki/GHC/Indexed_types">the Haskell
 wiki page on type families</ulink>.  The material will be moved to this user's
 guide when it has stabilised.
 </para>
@@ -4719,12 +4730,12 @@ Type families are enabled by the flag <option>-XTypeFamilies</option>.
 Haskell.  
 The background to
 the main technical innovations is discussed in "<ulink
-url="http://research.microsoft.com/~simonpj/papers/meta-haskell">
+url="http://research.microsoft.com/~simonpj/papers/meta-haskell/">
 Template Meta-programming for Haskell</ulink>" (Proc Haskell Workshop 2002).
 </para>
 <para>
 There is a Wiki page about
-Template Haskell at <ulink url="http://haskell.org/haskellwiki/Template_Haskell">
+Template Haskell at <ulink url="http://www.haskell.org/haskellwiki/Template_Haskell">
 http://www.haskell.org/haskellwiki/Template_Haskell</ulink>, and that is the best place to look for
 further details.
 You may also 
@@ -5547,7 +5558,7 @@ prefix notation:
 (!) f x = 3
 </programlisting>
 The semantics of Haskell pattern matching is described in <ulink
-url="http://haskell.org/onlinereport/exps.html#sect3.17.2">
+url="http://www.haskell.org/onlinereport/exps.html#sect3.17.2">
 Section 3.17.2</ulink> of the Haskell Report.  To this description add 
 one extra item 10, saying:
 <itemizedlist><listitem><para>Matching
@@ -5557,7 +5568,7 @@ the pattern <literal>!pat</literal> against a value <literal>v</literal> behaves
 		<literal>v</literal></para></listitem>
 </itemizedlist>
 </para></listitem></itemizedlist>
-Similarly, in Figure 4 of  <ulink url="http://haskell.org/onlinereport/exps.html#sect3.17.3">
+Similarly, in Figure 4 of  <ulink url="http://www.haskell.org/onlinereport/exps.html#sect3.17.3">
 Section 3.17.3</ulink>, add a new case (t):
 <programlisting>
 case v of { !pat -> e; _ -> e' }
@@ -5565,7 +5576,7 @@ case v of { !pat -> e; _ -> e' }
 </programlisting>
 </para><para>
 That leaves let expressions, whose translation is given in 
-<ulink url="http://haskell.org/onlinereport/exps.html#sect3.12">Section
+<ulink url="http://www.haskell.org/onlinereport/exps.html#sect3.12">Section
 3.12</ulink>
 of the Haskell Report.
 In the translation box, first apply 
@@ -7160,7 +7171,7 @@ carried out at let and where bindings.
           <indexterm><primary><option>-XNoMonomorphismRestriction</option></primary></indexterm>
 
 <para>Haskell's monomorphism restriction (see 
-<ulink url="http://haskell.org/onlinereport/decls.html#sect4.5.5">Section
+<ulink url="http://www.haskell.org/onlinereport/decls.html#sect4.5.5">Section
 4.5.5</ulink>
 of the Haskell Report)
 can be completely switched off by
@@ -7187,7 +7198,7 @@ can be completely switched off by
   [x] = e                    -- A pattern binding
 </programlisting>
 Experimentally, GHC now makes pattern bindings monomorphic <emphasis>by
-default</emphasis>.  Use <option>-XMonoPatBinds</option> to recover the
+default</emphasis>.  Use <option>-XNoMonoPatBinds</option> to recover the
 standard behaviour.
 </para>
 </sect2>