X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=e57b2946778a46e6cdb09e562c0a8fbc9a96636c;hp=dab683a429e880186e4225b6dc3ee0462b92bdd9;hb=7217f562ed08b7ef8a702065d437f7b6366aea88;hpb=22a25aa92bdbdcd4b29ada4cea187496b44bc53b

diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index dab683a..e57b294 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -3,8 +3,9 @@
 <indexterm><primary>language, GHC</primary></indexterm>
 <indexterm><primary>extensions, GHC</primary></indexterm>
 As with all known Haskell systems, GHC implements some extensions to
-the language.  They are all enabled by options; by default GHC
-understands only plain Haskell 98.
+the language.  They can all be enabled or disabled by commandline flags
+or language pragmas. By default GHC understands the most recent Haskell
+version it supports, plus a handful of extensions.
 </para>
 
 <para>
@@ -39,8 +40,7 @@ documentation</ulink> describes all the libraries that come with GHC.
     </indexterm>
 
     <para>The language option flags control what variation of the language are
-    permitted.  Leaving out all of them gives you standard Haskell
-    98.</para>
+    permitted.</para>
 
     <para>Language options can be controlled in two ways:
     <itemizedlist>
@@ -439,10 +439,10 @@ Indeed, the bindings can even be recursive.
 	  <listitem><para> <literal>'x'&num;</literal> has type <literal>Char&num;</literal></para> </listitem>
 	  <listitem><para> <literal>&quot;foo&quot;&num;</literal> has type <literal>Addr&num;</literal></para> </listitem>
 	  <listitem><para> <literal>3&num;</literal> has type <literal>Int&num;</literal>. In general,
-	  any Haskell 98 integer lexeme followed by a <literal>&num;</literal> is an <literal>Int&num;</literal> literal, e.g.
+	  any Haskell integer lexeme followed by a <literal>&num;</literal> is an <literal>Int&num;</literal> literal, e.g.
             <literal>-0x3A&num;</literal> as well as <literal>32&num;</literal></para>.</listitem>
 	  <listitem><para> <literal>3&num;&num;</literal> has type <literal>Word&num;</literal>. In general,
-	  any non-negative Haskell 98 integer lexeme followed by <literal>&num;&num;</literal> 
+	  any non-negative Haskell integer lexeme followed by <literal>&num;&num;</literal>
 	      is a <literal>Word&num;</literal>. </para> </listitem>
 	  <listitem><para> <literal>3.2&num;</literal> has type <literal>Float&num;</literal>.</para> </listitem>
 	  <listitem><para> <literal>3.2&num;&num;</literal> has type <literal>Double&num;</literal></para> </listitem>
@@ -450,43 +450,6 @@ Indeed, the bindings can even be recursive.
       </para>
    </sect2>
 
-    <sect2 id="new-qualified-operators">
-      <title>New qualified operator syntax</title>
-
-      <para>A new syntax for referencing qualified operators is
-        planned to be introduced by Haskell', and is enabled in GHC
-        with
-        the <option>-XNewQualifiedOperators</option><indexterm><primary><option>-XNewQualifiedOperators</option></primary></indexterm>
-        option.  In the new syntax, the prefix form of a qualified
-        operator is
-        written <literal><replaceable>module</replaceable>.(<replaceable>symbol</replaceable>)</literal>
-        (in Haskell 98 this would
-        be <literal>(<replaceable>module</replaceable>.<replaceable>symbol</replaceable>)</literal>),
-        and the infix form is
-        written <literal>`<replaceable>module</replaceable>.(<replaceable>symbol</replaceable>)`</literal>
-        (in Haskell 98 this would
-        be <literal>`<replaceable>module</replaceable>.<replaceable>symbol</replaceable>`</literal>.
-        For example:
-<programlisting>
-  add x y = Prelude.(+) x y
-  subtract y = (`Prelude.(-)` y)
-</programlisting>
-        The new form of qualified operators is intended to regularise
-        the syntax by eliminating odd cases
-        like <literal>Prelude..</literal>.  For example,
-        when <literal>NewQualifiedOperators</literal> is on, it is possible to
-        write the enumerated sequence <literal>[Monday..]</literal>
-        without spaces, whereas in Haskell 98 this would be a
-        reference to the operator &lsquo;<literal>.</literal>&lsquo;
-        from module <literal>Monday</literal>.</para>
-
-      <para>When <option>-XNewQualifiedOperators</option> is on, the old Haskell
-        98 syntax for qualified operators is not accepted, so this
-        option may cause existing Haskell 98 code to break.</para>
-
-    </sect2>
-        
-
     <!-- ====================== HIERARCHICAL MODULES =======================  -->
 
 
@@ -8242,7 +8205,7 @@ Here is an example:
 <para>
 Use the debug flag <option>-ddump-simpl-stats</option> to see what rules fired.
 If you need more information, then <option>-ddump-rule-firings</option> shows you
-each individual rule firing in detail.
+each individual rule firing and <option>-ddump-rule-rewrites</option> also shows what the code looks like before and after the rewrite.
 </para>
 
 <sect2>
@@ -8827,7 +8790,8 @@ If you add <option>-dppr-debug</option> you get a more detailed listing.
 
 <listitem>
 <para>
- Use <option>-ddump-rule-firings</option> to see in great detail what rules are being fired.
+ Use <option>-ddump-rule-firings</option> or <option>-ddump-rule-rewrites</option>
+to see in great detail what rules are being fired.
 If you add <option>-dppr-debug</option> you get a still more detailed listing.
 </para>
 </listitem>