--------------------------------
authorSimon Peyton Jones <simonpj@microsoft.com>
Mon, 2 Dec 2002 11:22:03 +0000 (11:22 +0000)
committerSimon Peyton Jones <simonpj@microsoft.com>
Mon, 2 Dec 2002 11:22:03 +0000 (11:22 +0000)
Just pre-CUP-publication version
--------------------------------

Includes all the changes that are in the CUP published version,
but still as two separate reports.  Next thing to do is to merge them.

44 files changed:
Makefile
haskell98-bugs.html
libraries/Makefile
libraries/char.verb
libraries/code/Array.hs
libraries/code/Char.hs
libraries/code/IO.hs
libraries/code/Ix.hs
libraries/code/Numeric.hs
libraries/code/Ratio.hs
libraries/headers/Ix.hs
libraries/headers/Numeric.hs
libraries/html.config
libraries/index.html
libraries/introduction.verb
libraries/io.verb
libraries/library.verb
libraries/list.verb
libraries/numeric.verb
report/Makefile
report/Prelude.hs
report/PreludeText.hs
report/basic.verb
report/classes.eps
report/classes.ppt
report/decls.verb
report/derived.verb
report/exps.verb
report/haskell.bbl
report/haskell.verb
report/html.config
report/index-intro.verb
report/index.html
report/intro.verb
report/io-13.verb
report/lexemes.verb
report/modules.verb
report/plain_haskell.verb
report/preface-13.verb
report/preface-jfp.verb
report/prelude-index.idx
report/syntax-iso.verb
report/syntax-lexical.verb
tools/tex.hs

index b7ed502..d496b70 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,22 @@
-
 RELEASE_DIR = haskell98-revised
+JFP_DIR = jfp-release
 
 release:
        (cd report; make release)
        (cd libraries; make release)
+       (cd jfp-release; make)
        cp h98-revised.html $(RELEASE_DIR)/index.html
        cp haskell98-bugs.html h98.gif $(RELEASE_DIR)
+       gzip < jfp-release/h98-book.ps > $(RELEASE_DIR)/h98-book.ps.gz
+       gzip < jfp-release/h98-book.pdf > $(RELEASE_DIR)/h98-book.pdf.gz
+
+jfp:
+       -mkdir $(JFP_DIR)
+       (cd report; make jfp)
+       (cd libraries; make jfp)
+
+# Places to change when you change the date of the Report
+#      h98-revised.html
+#      report/index.html   libraries/index.html
+#      report/html.config  libraries/html.config
+#      report/haskell.verb libraries/library.verb
index c9274fd..2e773dc 100644 (file)
@@ -41,7 +41,7 @@ that have become popular
 in functional programming.  In this Report, the meaning of such
 syntactic sugar is given by translation into simpler constructs.
 If these translations are applied exhaustively, the result is a program
-written in a small subset of Haskell that we call the Haskell <em>kernel</em>.
+written in a small subset of Haskell that we call the Haskell <em>kernel</em>."
 <p>
 "Although the kernel is not formally specified, it is essentially a
 slightly sugared variant of the lambda calculus with a straightforward
@@ -61,6 +61,11 @@ here, and item 2 of the list (which is related).
 Instead, amplify the remarks in Section 2.4 and 3.2.  This is a presentational
 change only.
 
+<p><li> [Sept 2002] <strong>Page 4, Section 2.1, Notational conventions.</strong>
+Remove the second-last paragraph altogether, which begins "Haskell uses a pre-processor...".
+(No implementation does this, and the reference to escapes in identifiers is inconsistent
+with the lexical syntax.)
+
 <p><li> [Late Dec 2001] <strong>Page 5, Section 2.2, Lexical program structure; and Appendix B.2, p120.</strong>
 Replace the production for "comment" with:
 <pre>
@@ -74,6 +79,22 @@ Replace the production for "comment" with:
 <pre>
  lexeme -> qvarid | qconid | qvarsym | qconsym | literal | special | reservedop | reservedid
 </pre>
+
+<p> <li> [March 02] Change the productions for <em>whitechar</em>  and <em>newline</em> to:
+<pre>
+  whitechar -> newline | vertab | space | tab | uniWhite
+  newline   -> return linefeed | return | linefeed | formfeed
+</pre>
+(This means that CR, LF, or CRLF (remember maximal munch), are all valid 'newline' separators,
+and the same sequence of characters should therefore work on any
+Haskell implementation.)
+
+<p> <li> [March 02] Change the production for <em>ANY</em> to
+<pre>
+  ANY -> graphic | whitechar
+</pre>
+(This is nicely similar to the production for "any".)
+
 <p> <li> Change the production for <em>uniDigit</em> to
 <pre>
   uniDigit -> any Unicode decimal digit
@@ -90,6 +111,17 @@ Replace the production for "comment" with:
 (These changes, and the next one, justify the productions for <em>program</em> which claims that a program is
 a sequence of lexemes and white space.)
 
+<p><li> [Feb 2002] <strong>Page 6, Section 2.2, Lexical program structure.</strong>
+In the first paragraph, delete the phrase ", using a context-independent 
+deterministic lexical analysis (i.e.~no lookahead beyond the current character is 
+required)". 
+<p>
+(The maximal munch rule is correct, but it's not true that it only takes one character
+of lookahead.  Consider
+"F. 9. 0o 0x 9.0e+f", which 
+should lex as "F . 9 . 0 o 0 x 9.0 e + f" but that needs up to two additional characters
+of lookahead.)
+
 <p><li> <strong>Page 7, Section 2.4, Identifiers and operators; and Appendix B.2, p121.</strong>
 Add <em>dashes</em> to <em>reservedop</em> in the exclusion set of the
 production for <em>varsym</em>.  (This ensures that "<tt>--</tt>" and
@@ -166,10 +198,50 @@ comprehension is used."
 <p>
 (Clarification only.)
 
+<p><li> [May 2002] <strong>Page 12, Section 3, Expressions; also Page 17, Section 3.5; 
+also Page 128, Appendix B, Syntax.</strong>  
+Add the following two extra productions for <em>aexp</em>:
+<pre>
+       |   '(' lexp(i) qop(l,i) ')'        left section
+        |   '(' qop(r,i)<sub>&lt;<tt>-</tt>&gt;</sub> rexp(i) ')'        right section
+</pre>
+and change the othe right-section production to:
+<pre>
+        |   '(' qop(a,i)<sub>&lt;<tt>-</tt>&gt;</sub> exp(i+1) ')'        right section
+</pre>
+(This brings the formal syntax into line with the 
+words in Section 3.5.  The grammar now follows the way that qfunlhs is defined.
+There is no ambiguity, because an exp(i+1) is not an lexp(i).)
+<p>
+The exclusion of "<tt>-</tt>" from right sections is also new [May 2002]; it is necessary
+to prevent overlap with the unary-minus syntax. 
+
 <p><li> [Aug 2001] <strong>Page 13, Section 3, Expressions.</strong>
 Remove Table 1, and the associated paragraph beginning "As an aid to
 understanding...".  (The table causes more confusion than it clears up.)
 
+<p><li> [March 2002] <strong>Page 14, Section 3, Expressions.</strong>
+After the sample parses, add the following paragraphs:
+<p>
+<em>A note about parsing.</em>  Expressions that involve the interaction 
+of fixities with the let/lambda meta-rule
+may be hard to parse.  For example, the expression
+<pre>
+  let x = True in x == x == True
+</pre>
+cannot possibly mean
+<pre>
+  let x = True in (x == x == True)
+</pre>
+because <tt>(==)</tt> is a non-associative operator; so the expression must parse thus:
+<pre>
+  (let x = True in (x == x)) == True
+</pre>
+However, implementations may well use a post-parsing pass to deal with fixities,
+so they may well incorrectly deliver the former parse.  Programmers are advised
+to avoid constructs whose parsing involves an interaction of (lack of) associativity
+with the let/lambda meta-rule.
+  
 <p><li> [Nov 2001] <strong>Page 13, Section 3 Expressions.</strong>
 Replace the curly braces by angle brackets, in the subscript of "aexp" in the last production of "aexp".
 Similarly, on Page 26, Section 3.15.3; and Page 128, Appendix B.4.
@@ -181,6 +253,28 @@ the section, after "indistinguishable" add "by a Haskell program".
 Remove the paragraph starting "Qualified names may only ...", and the following example, and the
 concluding paragraph starting "incorrectly uses a qualifier". (This is all covered in 2.4 and 5.5.1.)
 
+<p><li> [May 2002] <strong>Page 17, Section 3.5, Sections.</strong>
+Append the following to the paragraph beginning "Syntactic precedence rules apply to sections as follows."
+<p>
+"As another example, the expression
+<pre>
+  (let x = 10 in x +)
+</pre>
+is invalid because, by the let/lambda meta-rule (Section 3)
+the expression
+<pre>
+  (let n = 10 in n + x)
+</pre>
+parses as
+<pre>
+  (let n = 10 in (n + x))
+</pre>
+rather than
+<pre>
+  ((let n = 10 in n) + x)
+</pre>
+"
+
 <p><li> [Oct 2001] <strong>Page 18, Section 3.7, Lists.</strong>
 After the sentence starting "The constructor ":" is reserved solely for list construction...", 
 add the new sentence:
@@ -206,6 +300,23 @@ and no qualifier is empty.  The translation lower down page 23 is then
 not utterly rigorous, because Q can be empty, and when it is there is no preceding
 comma, but I reckon it would make matters worse to "fix" it.
 
+<p><li> [March 2002] <strong>Page 22, Section 3.13, Case Expressions</strong>.
+To the end of the section, add the following paragraphs:
+<p>
+<em>A note about parsing</em>.  The (type-incorrect) expression
+<pre>
+  case x of { (a,_) | let b = not a in b :: Bool -> a }
+</pre>
+is tricky to parse correctly.  It has a single unambiguous parse, namely
+<pre>
+  case x of { (a,b) | (let b = not a in b :: Bool) -> a }
+</pre>
+However, the phrase <tt>Bool -> a</tt> is syntactically valid as a type, and
+parsers with limited lookahead may incorrectly commit to this choice, and hence
+reject the program.  Programmers are advised, therefore, to avoid guards that
+end with a type signature --- indeed that is why a "gd" contains 
+an "exp^0" not an "exp".
+
 <p><li> [Apr 2001] <strong>Page 23, Section 3.14, Do Expressions; 
 and Page 128, Appendix B.4, Context Free Syntax.</strong>
 <ul>
@@ -222,6 +333,17 @@ followed by a semicolon.
 <p><li> [Aug 2001] <strong>Page 24, Section 3.15, Datatypes with Field Labels.</strong>.
 Add an example to illustrate the final point in para 2.
 
+<p><li> [Feb 2002] <strong>Page 25, Section 3.15.2, Construction Using Field Labels</strong>.
+At the end of the section add the sentence:
+<p>
+The expression <tt>F&nbsp;{}</tt>, where <tt>F</tt> is a data constructor, is legal 
+<I>whether or not </I><tt>F</tt><I> was declared with record syntax</I>, provided 
+<tt>F</tt> has no strict fields; it denotes 
+<tt>F</tt><I> _|_</I><sub><I>1</I></sub><I> ... _|_</I><sub><I>n</I></sub>, 
+where <I>n</I> is the arity of <tt>F</tt>.
+<p>
+(This matches the dual for pattern matching, in Section 4.2.1.)
+
 <p><li> [Aug 2001] <strong>Page 26, Section 3.15.3, Updates Using Field Labels</strong>.
 In the translation box: 
 <ul>
@@ -233,6 +355,15 @@ In the translation box:
 <p><li> [Aug 2001] <strong>Page 28, Section 3.17.1, Patterns.</strong>.
 Give an example to illustrate an illegal non-linear pattern.
 
+<p><li> [Jan 2002] <strong>Page 29, Section 3.17.2, Informal Semantics of Case Expressions.</strong>
+Reword the entire numbered list giving the informal semantics, so that:
+<ul>
+<li> It is clearly classified by pattern.
+<li> The semantics of matching a newtype pattern against bottom is given.
+<li> A literal and n+k pattern may not diverge even if the value matched is bottom; it
+depends on the definition of <tt>==</tt> and <tt>&gt;=</tt> respectively.
+</ul>
+
 <p><li> [Aug 2001] <strong>Page 31, Section 3.17.2, Informal Semantics of Case Expressions.</strong>
 Replace the example at the foot of Page 31, following the paragraph "The guard semantics...",
 with the following:
@@ -242,15 +373,6 @@ with the following:
 </pre>
 (The previous example use boolean and, which is non-strict in its second argument!)
 
-<p><li> [Jan 2002] <strong>Page 31, Section 3.17.2, Informal Semantics of Case Expressions.</strong>
-Reword the entire numbered list giving the informal semantics, so that:
-<ul>
-<li> It is clearly classified by pattern.
-<li> The semantics of matching a newtype pattern against bottom is given.
-<li> A literal and n+k pattern may not diverge even if the value matched is bottom; it
-depends on the definition of <tt>==</tt> and <tt>&gt;=</tt> respectively.
-</ul>
-
 <p><li> [Apr 2001] <strong>Page 31,33, Figures 3 and 4, Semantics of Case Expressions.</strong>
 Replace "completely new variable" by "new variable" in these two figures.  (Some clauses
 said "new" and some "completely new" which is misleadingly inconsistent.)
@@ -267,11 +389,23 @@ In clause (r) replace "e0" by "v" throughout.
 </pre>
 <li> Rename old clause (r) as clause (s).
 <li> Use lambda instead of let in the new clause (s), so as to avoid the suggestion
-of polymorphism (just as in other clauses.
+of polymorphism (just as in other clauses).
 <li> In the accompanying text, final paragaph, add clause (s) to the list of 
 clauses that use lambda to avoid suggesting polymorphism.
 </ul>
 
+<p><li> [May 2002] <strong>Page 34, Section 4, Declarations and Bindings; 
+                      and Page 44, Section 4.3.1, Class Declarations.</strong>
+In the production for <tt>class</tt>, replace
+<pre>
+       class [scontext =>] simpleclass [where decls]
+</pre>
+by
+<pre>
+       class [scontext =>] tycls tyvar [where decls]
+</pre>
+
+
 <p><li> [Sept 2001] <strong>Page 36, Section 4.1.2, Syntax of Types.</strong>
 First paragraph, last sentence.  After "infix type constructors are not allowed",
 add "(other than <tt>(->)</tt>)".
@@ -458,12 +592,17 @@ legal
 </ul>
 (These changes clarify the scope rules for export lists.  Much email discussion during Dec 2001.)
 
-<p><li> [Oct 2001] <strong>Page 64, Section 5.2, Export declarations, numbered items 5 and 6.</strong>
+<p>
+<li> [March 02] In point (2) delete the sentence "The qcnamei must not conatin duplications.".
+Make a similar change in point (4). 
+
+<p><li> [Oct 2001, modified Nov 2002] <strong>Page 64, Section 5.2, Export declarations, numbered items 5 and 6.</strong>
 Replace both items with the following:
 <p>
-"The form `<tt>module M</tt>' abbreviates the set of all entities whose
-<em>unqualified</em> name, <em>e</em>, is in scope, and for which the <em>qualified</em> name
-<em>M.e</em> is also in scope and refers to the same entity as <em>e</em>.  This set
+The form "<tt>module M</tt>" names the set of all entities that are in
+scope with both an unqualified name "<tt>e</tt>" and a qualified name
+"<tt>M.e</tt>".
+This set
 may be empty.
 For example:
 <pre>
@@ -515,6 +654,11 @@ between <tt>C.g</tt> and <tt>g</tt>,
 and between <tt>module B</tt> and <tt>C.f</tt> (assuming <tt>B.f</tt> and <tt>C.f</tt> are different entities), 
 even though there are no name clashes within module <tt>A</tt> itself.  
 
+<p><li> [Feb 2002] <strong>Page 65, Section 5.3, Import Declarations, syntax; also page 125, Appendix B.4.</strong>
+In the second production for "import", namely "tycon [ [(..)] | (cname1, ..., cnamen)]"
+replace "n&gt;=1" by "n&gt;=0".  (There is no need to require one or more constructors, and 
+in <tt>hiding</tt> clauses it may be useful to hide the type constructor only.)
+
 <p><li> [Nov 2001] <strong>Page 65, Section 5.3, Import Declarations, last line.</strong>
 Before "Exactly which entities are to be imported..." add a new paragraph:
 <p>
@@ -594,9 +738,9 @@ with an explicit <tt>import</tt> declaration. This provision for explicit
 import allows entities defined in the Prelude to be selectively imported,
 just like those from any other module."
 
-<p><li> <strong>Page 71, Section 5.6.2, Shadowing Prelude Names.</strong> 
-Replace the example at the beginning of the section, and the entire
-following paragraph, with the following
+<p><li> [May 2002] <strong>Page 71, Section 5.6.2, Shadowing Prelude Names.</strong> 
+Replace the entire section with the following, which clarifies matters considerably
+compared to the original Haskell 98 Report.
 "<pre>
   module A( null, nonNull ) where
     import Prelude hiding( null ) 
@@ -611,7 +755,36 @@ The latter would be ambiguous without the "<tt>hiding(null)</tt>" on the
 Every module that imports <tt>A</tt> unqualified, and then makes an unqualified
 reference to <tt>null</tt> must also resolve the ambiguous use of <tt>null</tt>
 just as <tt>A</tt> does.  Thus there is little danger of accidentally shadowing 
-Prelude names."
+Prelude names.
+<p>
+"It is possible to construct and use a different module to serve in
+place of the Prelude.  Other than the fact that it is implicitly
+imported, the Prelude is an ordinary Haskell module; it is special
+only in that some objects in the Prelude are referenced by special
+syntactic constructs.  Redefining names used by the Prelude does not
+affect the meaning of these special constructs.  For example, in
+<pre>
+  module B where
+    import Prelude()
+    import MyPrelude
+    f x = (x,x)
+    g x = (,) x x
+    h x = [x] ++ []
+</pre>
+the explicit <tt>import Prelude()</tt> declaration prevents the automatic
+import of <tt>Prelude</tt>, while the declaration <tt>import MyPrelude</tt> brings the
+non-standard prelude into scope.  
+The special syntax for tuples (such as <tt>(x,x)</tt> and <tt>(,)</tt>) and lists
+(such as <tt>[x]</tt> and <tt>[]</tt>) continues to refer to the tuples and lists
+defined by the standard <tt>Prelude</tt>;
+there is no way to redefine the meaning of <tt>[x]</tt>, for example, in terms of a
+different implementation of lists.
+On the other hand, the use of <tt>++</tt> is not special syntax, so it refers
+to <tt>++</tt> imported from <tt>MyPrelude</tt>.
+<p>
+"It is not possible, however, to hide <tt>instance</tt> declarations in the
+<tt>Prelude</tt>.  For example, one cannot define a new instance for <tt>Show Char</tt>."
+
 
 <p><li> [Aug 2001]  <strong>Page 74, Section 6.1.3, Lists.</strong>  In the last sentence,
 after "<tt>Monad</tt>" add ", <tt>Functor</tt>".  (The list type is an instance of <tt>Functor</tt>.)
@@ -662,6 +835,17 @@ to and from strings." add the sentence:
 precedence of the enclosing context (see Appendix D.4)."
 (Clarification only.)
 
+<p><li> [May 2002] <strong> Page 79, Section 6.3.3, The Read and Show Classes.</strong>
+Add documentation for the function <tt>lex</tt>:
+<p>
+"The function <tt>lex :: ReadS String</tt>, used by <tt>read</tt>, is also part of the Prelude.
+It reads a single lexeme from the input, discarding initial white space, and
+returning the characters that constitute the lexeme.  If the input string contains
+only white space, <tt>lex</tt> returns a single successful ``lexeme'' consisting of the
+empty string.  (Thus <tt>lex ""</tt> = <tt>[("","")]</tt>.)  If there is no legal lexeme at the
+beginning of the input string, <tt>lex</tt> fails (i.e. returns <tt>[]</tt>)."
+
+
 <p><li> [Nov 2001] <strong> Page 79, Section 6.3.4, Class Enum; 
 Page 19, Section 3.10 Arithmetic Sequences; and Appendix D.2, Derived instances of Enum.</strong>
 <ul>
@@ -709,6 +893,22 @@ In the section "Input functions" replace "the <tt>IOError</tt> value associated
 with end-of-file is defined in a library" by "a predicate <tt>isEOFError</tt> that 
 identifies this exception is defined in the <tt>IO</tt> library".
 
+<p><li> [May 2002] <strong>Page 88, Section 7.1, Standard I/O functions.</strong>
+In the section "Input functions", 
+<ul>
+<li> Change "Both <tt>getChar</tt> and <tt>getLine</tt> raise an exception on end-of-file;" to
+"The <tt>getChar</tt> operation raises an exception on end-of-file;".
+<li> After that sentence, add the further sentence "The <tt>getLine</tt> operation raises 
+an exception under the same circumstances as <tt>hGetLine</tt>, defined the <tt>IO</tt> library."
+</ul>
+(This change goes along with a more precise description of the behaviour of hGetLine.)
+
+<p><li> [Sept 2002] <strong>Page 88, Section 7.1, Standard I/O functions.</strong>
+Remove the paragraph "By default, these input functions echo to standard output."
+(There was a lot of discussion on the Haskell mailing list on this point, in Sept 2002.
+The conclusion was that the sentence should go, though it would have been better
+to craft something more detailed.)
+
 <p><li><strong>Page 90, Section 7.3, Exception handling in the IO monad.</strong>
 After the first paragraph give the following type signature:
 <pre>
@@ -802,6 +1002,17 @@ Replace "<tt>1.0</tt>" by "<tt>0.95</tt>".
 <p><li> [Aug 2001] <strong>Page 101, Appendix A, instance of <tt>Monad IO</tt>.</strong>
 Delete defintion for <tt> >> </tt>.  (The default definition will do.)
 
+<p> <li> [Oct 2002] <strong>Page 103, Appendix A.1, line 19.</strong>
+In the definition of <tt>numericFromThenTo</tt> replace "<tt>n' > n</tt>" by
+"<tt>n' >= n</tt>".  So the definition now reads:
+<pre>
+numericEnumFromThenTo n n' m = takeWhile p (numericEnumFromThen n n')
+                             where
+                               p | n' >= n   = (<= m + (n'-n)/2)
+                                 | otherwise = (>= m + (n'-n)/2)
+</pre>
+(This change makes the code agree with the last bullet in (the revised version of) 6.3.4.)
+
 <p> <li> [Apr 2001] <strong>Page 105, Appendix A.1, line 11.</strong>
 In the module header for <tt>PreludeList</tt> replace "<tt>Sum</tt>" by "<tt>sum</tt>".
 
@@ -864,7 +1075,7 @@ Replace the definitions of <tt>take</tt>, <tt>drop</tt>, and <tt>splitAt</tt> wi
 The effect is that all three functions are defined on negative arguments.  This
 is a semantic change.
 
-<p><li> [Jan 2002] <strong>Page 113, header for PreludeText</strong>.
+<p><li> [Jan 2002] <strong>Page 112, header for PreludeText</strong>.
 Remove <tt>show</tt> from the export list, and re-insert it as an exported
 operation of class <tt>Show</tt>.
 
@@ -895,6 +1106,18 @@ Replace the instances for <tt>Show Int</tt> and <tt>Read Int</tt> with
 </pre>
 The previous definitions (which are simply specifications, remember) failed on minInt.
 
+<p><li> [July 2002]
+<strong>Page 115, instances <tt>Read Float</tt> and <tt>Read Double</tt></strong>. 
+These two instance declarations should read:
+<pre>
+    instance  Read Float  where
+       readsPrec p         = readSigned readFloat
+    
+    instance  Read Double  where
+       readsPrec p         = readSigned readFloat
+</pre>
+(Adding the 'readSigned' call.)
+
 <p><li> [Late Dec 2001] <strong>Page 118, defn of <tt>interact</tt></strong>. 
 Replace the definition of <tt>interact</tt> with the following.
 <pre>
@@ -918,19 +1141,27 @@ next lexeme if there is one, or "0" if the end of file has been reached."
 
 <p><li>Replace the third dashed item in the first bullet item by:
 <p>
-"Where the start of a token does not follow any complete token on the
+"Where the start of a token is preceded only by white space on
    same line, this token is preceded by "&lt;n&gt;" where "n"
    is the indentation of the token, provided that it is not,
    as a consequence of the first two rules, preceded by "{n}".
 <p>
 (This addresses the question of empty lines (no layout token) and string-gap tokens
-(no layout token in the middle of them).
+(no layout token in the middle of them).  I have added a clarifying example as well.)
 </ul>
 
 <p><li> [Nov 2001]  <strong>Page 122, Appendix B.3, Layout</strong>. 
 In the paragraph following the bullets, add the sentence:
 "The characters "newline", "return", "linefeed", and "formfeed", all start a new line."
 
+<p><li> [Sept 2002]  <strong>Page 122, Appendix B.3, Layout</strong>. 
+After the sentence "For the purposes of the layout rule, Unicode characters in a source program
+are considered to be of the same, fixed, width as an ASCII character." add the clarifying sentence
+<p>
+"However, to avoid visual confusion, programmers should avoid writing programs in which 
+the meaning of implicit layout depends on the width of non-space characters."
+
+
 <p><li> [Oct 2001]  <strong>Page 123, Appendix B.3, Layout</strong>. 
 In the first line of the definition of L, replace "if parse-error(t)" by
 "if m /= 0 and parse-error(t)".  This checks that the implicitly-added close
@@ -963,6 +1194,26 @@ that the tokens "&lt;n&gt;" and "{n}" are never passed to "parse-error".)
 Near the end of the sub-section, delete from "Another place where..." to the end of the 
 sub-section.  (Note 5 covers the top-level case.)
 
+<p><li> [May 2002] <strong>Page 124, Appendix B.3, Layout</strong>
+To the very end of B.3, append the following:
+<p>
+"The parse-error rule is hard to implement in its full generality, because 
+doing so involves fixities.  For example, the expression
+<pre>
+  do a == b == c
+</pre>
+has a single unambiguous (albeit probably type-incorrect) parse, namely
+<pre>
+  (do { a == b }) == c
+</pre>
+because <tt>(==)</tt> is non-associative.   Programmers are therefore advised to avoid
+writing code that requires the parser to insert a closing brace in such
+situations."
+
+<p><li> [Sept 2002]  <strong>Page 130, Appendix C, Literate comments</strong>. 
+Move Appendix C (Literate comments) into Appendix B (Syntax), just after the section on Layout.
+(This structure makes more sense when the report appears as a book.)
+
 <p><li> [Oct 2001]  <strong>Page 130, Appendix C, Literate comments</strong>. 
 In paragraph 2, replace 
 "The program text is recovered
@@ -989,13 +1240,95 @@ In numbered item 3, replace
 ``(all constructors must by nullary)'' with 
 ``(all constructors must be nullary)''.
 
+<p><li> [Jan 2002]  <strong>Page 132, Appendix D, Specification of Derived Instances</strong>. 
+Mention that computing the context for the derived instance declaration may involve
+a fixpoint calculation.
+
+<p><li> [Feb 2002, modified Oct 2002]  <strong>Page 133, Appendix D.1, Derived Instances of Eq and Ord</strong>. 
+Add the final sentence: 
+<p>
+All derived operations of class <tt>Eq</tt> and <tt>Ord</tt> are strict in both arguments.
+For example, <tt>False &lt;=</tt> _|_ is _|_ , even though <tt>False</tt> is the first constructor
+of the <tt>Bool</tt> type.
+
+<p><li> [Oct 2002] <strong>Page 134, Appendix D.4, Derived instances of Read and Show</strong>.
+<ul>
+<li> In para 2, replace "10" by "11".  Thus "(a number from 0 to 11)".
+
+<li> In para 3 replace "...if <tt>d</tt> is 10 it is always surrounded
+in parentheses, unless it is an atomic expression." by:
+"if <tt>d</tt> is 11 it is always surrounded in parentheses, unless it is an
+atomic expression (recall that function application has precedence 10)."
+</ul>
+
+
 <p><li> [June 2001] <strong>Page 134, Appendix D.4, Derived instances of Read and Show</strong>.
 In the displayed equation starting <tt>fst (head (...)) == x</tt>, replace "<tt>r</tt>" by
 the empty string, resulting in the following:
+<p>
+<center>
+  <tt>(x,"")</tt> is an element of <tt>(readsPrec d (showsPrec d x ""))</tt>
+</center>
+<p>
+(The old, stronger, equation is simply false.)
+
+<p><li> [Oct 2002] <strong>Page 135, Appendix D.4, Derived instances of Read and Show</strong>.
+In para 1, replace "<tt>readsPrec</tt> will parse any valid representation of the standard types 
+apart from lists, for
+which only the bracketed form [...] is accepted." by:
+<p>
+"<tt>readsPrec</tt> will parse any valid representation of the standard types 
+apart from strings, for which only quoted strings are accepted, and other lists,
+for which only the bracketed form [...] is accepted."
+
+
+<p><li> [May 2002] <strong>Page 135, Appendix D.4, Derived instances of Read and Show</strong>.
+Replace the paragraph starting "A precise description of the derived...", and all the following
+bullets, with the following 
+(the main change is to make Show ignore associativity, so that
+a simple derived parser will terminate even on left-recursive inputs):
+
+<p>
+The result of <tt>show</tt> is a syntactically correct Haskell expression
+containing only constants, given the fixity declarations in force at
+the point where the type is declared.  It contains only the
+constructor names defined in the data type, parentheses, and
+spaces. When labelled constructor fields are used, braces, commas,
+field names, and equal signs are also used.  Parentheses
+are only added where needed, ignoring associativity.  No line breaks
+are added. The result of <tt>show</tt> is readable by <tt>read</tt> if all component
+types are readable.  (This is true for all instances defined in the
+Prelude but may not be true for user-defined instances.)
+<p>
+Derived instances of <tt>Read</tt> make the following assumptions, 
+which derived instances of <tt>Show</tt> obey:
+<ul>
+<li> If the constructor is defined to be an infix operator, then 
+the derived <tt>Read</tt> instance will parse only infix applications of the 
+constructor (not the prefix form).
+
+<li> Associativity is not used to reduce the occurrence of 
+parentheses, although precedence may be. For example, given
 <pre>
-  head (readsPrec d (showsPrec d x "")) == (x,"")
+  infixr :$
+  data T = Int :$ T  |  NT
 </pre>
-(The old, stronger, equation is simply false.)
+then:
+<ul>
+<li> <tt>show (1 :$ 2 :$ NT)</tt> produces the string <tt>"1 :$ (2 :$ NT)"</tt>.
+<li> <tt>read "1 :$ (2 :$ NT)"</tt> succeeds, with the obvious result.
+<li> <tt>read "1 :$ 2 :$ NT"</tt> fails.
+</ul>
+
+<li>
+If the constructor is defined using record syntax, the derived <tt>Read</tt> 
+will parse only the record-syntax form, and furthermore, the fields must be 
+given in the same order as the original declaration.
+
+<li> The derived <tt>Read</tt> instance allows arbitrary Haskell whitespace between 
+tokens of the input string.  Extra parenthese are also allowed."
+</ul>
+
 
 <p><li> [Aug 2001]  <strong>Page 138, Appendix E, Compiler pragmas</strong>.
 <ul>
@@ -1031,6 +1364,13 @@ Haskell 98 Programming Language, 1 February 1999".
 <li> Correct type of <tt>getLine</tt> to <tt>IO String</tt>
 <li> [Jan 2002] Correct type of <tt>map</tt> and add entry for <tt>fmap</tt>.
 <li> [Jan 2002] Add entry for <tt>filter</tt>
+<li> [Feb 2002] The equations given for foldl and foldr were wrong. They
+should be
+<pre>
+    foldl (+) 0 [a,b,c] = ((0+a)+b)+c
+    foldr (+) 0 [a,b,c] = a+(b+(c+0))
+</pre>
+Furthermore, the function name was misspelled in the equation for foldr1.
 </ul>
 </ul>
 
@@ -1061,6 +1401,34 @@ Replace the definition of <tt>recip</tt> on line 3 by the following
 The effect of this change is to use the "smart constructor", <tt>%</tt>, instead
 doing it by hand.  In particular, an error will be raised if y is zero.
 
+<p><li>  [Oct 2002] <strong>Page 5, Section 2.1, Library <tt>Ratio</tt></strong>.
+Add the following definitions to the instance for <tt>Enum</tt>.
+<pre>
+    succ x           =  x+1
+    pred x           =  x-1
+</pre>
+(This makes succ/pred behave in the same way for Ratio as they do for Float and Double.
+Of course, it is still highly dubious having these fractional types in Enum at all,
+but that is another matter.)
+
+<p><li>  [July 2002] <strong>Page 5, Section 2.1, Library <tt>Ratio</tt></strong>.
+Modify the <tt>Read</tt> and <tt>Show</tt> instances of <tt>Ratio</tt> as follows:
+<pre>
+  instance  (Read a, Integral a)  => Read (Ratio a)  where
+    readsPrec p  =  readParen (p > prec)
+                              (\r -> [(x%y,u) | (x,s)   <- readsPrec (prec+1) r,
+                                                ("%",t) <- lex s,
+                                                (y,u)   <- readsPrec (prec+1) t ])
+
+  instance  (Integral a)  => Show (Ratio a)  where
+    showsPrec p (x:%y)  =  showParen (p > prec)
+                               (showsPrec (prec+1) x . 
+                               showString " % " . 
+                               showsPrec (prec+1) y)
+
+</pre>
+(It is important that the recursive calls carry the appropriate precedence.)
+
 <p><li> [Nov 2001] <strong>Page 9, Numeric library</strong>.
 <ul>
 <li> Add <tt>showIntAtBase</tt>, <tt>showHex</tt>, and <tt>showOct</tt> to the export list.
@@ -1148,6 +1516,10 @@ of <tt>readFloat</tt>, after "... <tt>(k,t) <- readExp s]</tt>" add
 (This makes <tt>readFloat</tt> able to read "Infinity" and "NaN", which <tt>formatRealFloat</tt>
 can produce.)
 
+<p><li> [May 2002] <strong>Page 9, Section 4, Numeric library</strong>.  In the type for
+<tt>readFloat</tt> replace "<tt>(RealFloat a)</tt>" by "<tt>(RealFrace a)</tt>".
+(This makes it possible to read a Rational number using readFloat.)
+
 <p><li> <strong>Page 17, Section 5, first text line</strong>.  Replace "continuous" by "contiguous".
 
 <p><li> [May 2001] <strong>Page 17, Section 5, Indexing operations</strong>.  
@@ -1164,8 +1536,9 @@ change is visible to the programmer, all existing Haskell 98
 programs will continue to work.
 
 <ul>
-<li>  <strong>Page 17, Section 5, Indexing operations, boxed text</strong>. Replace the <tt>Ix</tt>
-change the class declaration, and the type signature for <tt>rangeSize</tt> with:
+<li>  <strong>Page 17, Section 5, Indexing operations, boxed text</strong>. 
+Replace the <tt>Ix</tt>
+class declaration, and the type signature for <tt>rangeSize</tt> with:
 <pre>
   class Ord a => Ix a where
     range     :: (a,a) -> [a]
@@ -1192,6 +1565,7 @@ class declaration, and the <tt>rangeSize</tt> declaration, with:
 </pre>
 (Note: the comment has changed too; it was misleading before.)
 </ul>
+(Note: an earlier proposal to remove the Ord superclass was rejected.)
 
 <p><li> [July 2001] <strong>Page 17, Section 5.1, Derived instances of <tt>Ix</tt></strong>.
 Replace the first paragraph with the following:
@@ -1216,12 +1590,36 @@ In the definition of <tt>diag</tt>, delete the guard ``<tt>| l==l' &amp;&amp; u=
 (The original intent was presumably to check for a square array, but
  simply makes the definition recursive and hence divergent.)
 
+<p><li>  [July 2002] <strong>Page 24, Section 6.4, Library <tt>Array</tt></strong>.
+Use the following <tt>Read</tt> and <tt>Show</tt> instances for <tt>Array</tt>:
+<pre>
+  instance  (Ix a, Show a, Show b) => Show (Array a b)  where
+    showsPrec p a = showParen (p > arrPrec) (
+                    showString "array " .
+                    showsPrec (arrPrec+1) (bounds a) . showChar ' ' .
+                    showsPrec (arrPrec+1) (assocs a)                  )
+
+  instance  (Ix a, Read a, Read b) => Read (Array a b)  where
+    readsPrec p = readParen (p > arrPrec)
+           (\r -> [ (array b as, u) 
+                  | ("array",s) <- lex r,
+                    (b,t)       <- readsPrec (arrPrec+1) s,
+                    (as,u)      <- readsPrec (arrPrec+1) t ])
+
+  -- Precedence of the 'array' function is that of application itself
+  arrPrec = 10
+</pre>
+(It is important that the recursive calls use the appropriate precedence.)
+
 <p><li> <strong>Page 29, Section 7.2</strong>.  Add a new bullet for <tt>nub</tt>.
 Add an index entry for <tt>nub</tt>.
 
 <p><li> <strong>Page 29, Section 7.2, second bullet</strong>.  
 Introduce a new bullet just before "<tt>union</tt> is list union".
 
+<p><li> [July 2002] <strong>Page 29, Section 7.2, third bullet</strong>.  
+Remove the first <tt>intersect</tt> in the displayed equation.
+
 <p><li> <strong>Page 30, Section 7.3</strong>.  Add a bullet for <tt>insert</tt>.
 
 <p><li> [May 2001] <strong>Page 30, Section 7.4, unfoldr</strong>.
@@ -1237,6 +1635,15 @@ In some cases, <tt>unfoldr</tt> can undo a <tt>foldr</tt> operation:"
 <p>
 (Followed by the existing displayed equation.)
 
+<p><li> [Feb 2002] <strong>Page 31, Section 7.6, The "By" operations</strong>.
+Change the defintion of <tt>nub</tt> to:
+<pre>
+  nub        :: (Eq a) => [a] -> [a]
+  nub []     =  []
+  nub (x:xs) =  x : nub (filter (\y -> not (x == y)) xs)
+</pre>
+(This eliminates a conflict with the definition in Section 7.8.)
+
 <p><li> [Apr 2001] <strong>Page 31, Section 7.7, Library List</strong>.
 Add a new subsection "The zip operations" to document zip4, zip5, etc.
 
@@ -1280,10 +1687,33 @@ consistent with the other "By" functions, and with the signatures given on page
 <p><li> [Dec 2001] <strong>Page 41, Sections 9, Character utilities</strong>.
 Add an explanation of <tt>lexLitChar</tt>, and an example.
 
-<p><li> [Jan 2002] <strong>Page 43, Sections 9.1, Character utilities</strong>.
+<p><li> [Jan 2002] <strong>Page 43, Sections 9.1, Library Char</strong>.
 Add <tt>isLatin1</tt> to the list of variables in the type signature 
 for "character-testing operations".
 
+<p><li> [May 2002] <strong>Page 45, Sections 9.1, Library Char</strong>.
+Replace the first equation for <tt>lexLitChar</tt> with the following
+<pre>
+  lexLitChar ('\\':s) =  map (prefix '\\') (lexEsc s)
+        where
+          lexEsc (c:s)     | c `elem` "abfnrtv\\\"'" = [([c],s)]
+          lexEsc ('^':c:s) | c >= '@' && c <= '_'    = [(['^',c],s)]
+
+         -- Numeric escapes
+         lexEsc ('o':s)               = [prefix 'o' (span isOctDigit s)]
+         lexEsc ('x':s)               = [prefix 'x' (span isHexDigit s)]
+          lexEsc s@(d:_)   | isDigit d = [span isDigit s]
+
+          -- Very crude approximation to \XYZ.  
+          lexEsc s@(c:_)   | isUpper c = [span isCharName s]
+          lexEsc _                     = []
+
+          isCharName c   = isUpper c || isDigit c
+         prefix c (t,s) = (c:t, s)
+</pre>
+(The effect is to allow octal and hexadecimal escapes in lexLitChar, just
+as in readLitChar.)
+
 <p><li><strong>Page 48, Sections 10.3, Monads</strong>.
 In the definition of <tt>listFile</tt> replace "<tt>openFile</tt>" by "<tt>readFile</tt>".
 
@@ -1334,6 +1764,17 @@ consumed.  It follows that an attempt to write to a file (using <tt>writeFile</t
 that was earlier opened by <tt>readFile</tt> will usually result in 
 failure with <tt>isAlreadyInUseError</tt>."
 
+<p><li> [Sept 2002] <strong>Page 58, Section 11.3.2 Closing Files</strong>.
+Replace the sentence "If the operation fails for any reason ... successfully closed."
+by
+<p>
+"Performing <tt>hClose</tt> on a handle that has already been closed has no effect; 
+doing so not an error.  All other operations on a closed handle will fail.
+If <tt>hClose</tt> fails for any reason, any further operations (apart from <tt>hClose</tt>) on the 
+handle will still fail as if "hdl" had been successfully closed."
+<p>
+(The significant change here is that it is not an error to hClose a handle twice.)
+
 <p><li> [May 2001] <strong>Page 59, Section 11.4.2</strong>.
 Before "The buffer is emptied as soon as it has been written out." add: 
 "An implementation is free to flush the buffer more frequently, but not 
@@ -1345,6 +1786,21 @@ In the second no-buffering bullet (sixth bullet in the sub-section) add the
 sentence: "The <tt>hLookAhead</tt> operation implies that
 even a no-buffered handle may require a one-character buffer. "  (Clarification only.)
 
+<p><li>[May 2002] <strong>Page 60, Section 11.7.1, Checking for input</strong>.
+<ul>
+<li> Split this section into two: 11.7.1 Checking for input (describing
+<tt>hWaitForInput</tt> and <tt>hReady</tt>), and 11.7.2 Reading input (describing
+<tt>hGetChar</tt> and <tt>hGetLine</tt>).
+<p>
+<li> To the new section 11.7.2, add the following description of <tt>hGetLine</tt>
+exception behaviour:
+<p>
+"The <tt>hGetLine</tt> fails with <tt>isEOFError</tt> if the end of file is encountered
+when reading the <em>first</em> character of the line. If <tt>hGetLine</tt> encounters
+end-of-file at any other point while reading in a line, it is treated as
+a line terminator and the (partial) line is returned."
+</ul>
+
 <p><li><strong>Page 62, Section 11.7.2</strong>.
 <ul>
 <li>Add a new section heading "<strong>11.7.3 Reading the entire input</strong>"
index ec7fece..cbd8335 100644 (file)
@@ -40,6 +40,7 @@ EXPAND = expand
 # generator so I'm changing the .verb files to lower case  -- jcp
 
 RELEASE_DIR = ../haskell98-revised
+JFP_DIR = ../jfp-release
 
 PARTS =                library.tex introduction.tex ratio.tex complex.tex ix.tex \
                 numeric.tex \
@@ -140,6 +141,12 @@ release: library.ps html
 publish-pdf: library.pdf
        gzip < library.pdf > y:Haskell/haskell98-library/library.pdf.gz
 
+jfp: ${PARTS} ${CODE} ${HEADERS} index-intro.tex
+       -mkdir $(JFP_DIR)
+       -mkdir $(JFP_DIR)/code
+       -mkdir $(JFP_DIR)/headers
+       for n in ${PARTS}  ${CODE}  ${HEADERS}; do  \
+               ../tools/subsection < $$n >  $(JFP_DIR)/$$n ; done 
 
 #########################################
 #      Suffix rules
index a9db06b..ad3fbe2 100644 (file)
@@ -59,7 +59,7 @@ a single digit @Char@ and the corresponding @Int@.
 @digitToInt@ operates fails unless its argument satisfies @isHexDigit@,
 but recognises both upper and lower-case hexadecimal digits (i.e. @'0'@..@'9'@,
 @'a'@..@'f'@, @'A'@..@'F'@).  @intToDigit@ fails unless its argument is in the range
-@0@..@15@, and generates lower-case hexadecmial digits.
+@0@..@15@, and generates lower-case hexadecimal digits.
 
 The @isSpace@ function recognizes only white characters in the Latin-1
 range.
@@ -74,7 +74,7 @@ to the character that it encodes.  For example:
 @
   showLitChar '\n' s       =  "\\n" ++ s
   lexLitChar  "\\nHello"   =  [("\\n", "Hello")]
-  readLitChar "\\nHello"   =  [("\n", "Hello")]
+  readLitChar "\\nHello"   =  [('\n', "Hello")]
 @
 \eprog
 
index 6cde345..ad100bf 100644 (file)
@@ -69,13 +69,17 @@ instance  (Ix a, Ord b) => Ord (Array a b)  where
     a <= a' =  assocs a <= assocs a'
 
 instance  (Ix a, Show a, Show b) => Show (Array a b)  where
-    showsPrec p a = showParen (p > 9) (
+    showsPrec p a = showParen (p > arrPrec) (
                     showString "array " .
-                    shows (bounds a) . showChar ' ' .
-                    shows (assocs a)                  )
+                    showsPrec (arrPrec+1) (bounds a) . showChar ' ' .
+                    showsPrec (arrPrec+1) (assocs a)                  )
 
 instance  (Ix a, Read a, Read b) => Read (Array a b)  where
-    readsPrec p = readParen (p > 9)
-           (\r -> [(array b as, u) | ("array",s) <- lex r,
-                                     (b,t)       <- reads s,
-                                     (as,u)      <- reads t   ])
+    readsPrec p = readParen (p > arrPrec)
+           (\r -> [ (array b as, u) 
+                  | ("array",s) <- lex r,
+                    (b,t)       <- readsPrec (arrPrec+1) s,
+                    (as,u)      <- readsPrec (arrPrec+1) t ])
+
+-- Precedence of the 'array' function is that of application itself
+arrPrec = 10
index c1d1ccf..ab08471 100644 (file)
@@ -6,7 +6,7 @@ module Char (
     ord, chr,
     readLitChar, showLitChar, lexLitChar,
 
-       -- ...and what the Prelude exports
+        -- ...and what the Prelude exports
     Char, String
     ) where
 
@@ -27,11 +27,11 @@ isControl c              =  c < ' ' || c >= '\DEL' && c <= '\x9f'
 isPrint                  =  primUnicodeIsPrint
 
 isSpace c                =  c `elem` " \t\n\r\f\v\xA0"
-       -- Only Latin-1 spaces recognized
+        -- Only Latin-1 spaces recognized
 
-isUpper                  =  primUnicodeIsUpper -- 'A'..'Z'
+isUpper                  =  primUnicodeIsUpper  -- 'A'..'Z'
 
-isLower                  =  primUnicodeIsLower -- 'a'..'z'
+isLower                  =  primUnicodeIsLower  -- 'a'..'z'
 
 isAlpha c                =  isUpper c || isLower c
 
@@ -61,52 +61,52 @@ intToDigit i
 
 
 -- Case-changing operations
-toUpper                  :: Char -> Char
-toUpper                  =  primUnicodeToUpper
-
-toLower                  :: Char -> Char
-toLower                  =  primUnicodeToLower
+toUpper :: Char -> Char
+toUpper =  primUnicodeToUpper
+        
+toLower :: Char -> Char
+toLower =  primUnicodeToLower
 
 -- Character code functions
-ord                     :: Char -> Int
-ord                     =  fromEnum
-
-chr                     :: Int  -> Char
-chr                     =  toEnum
+ord  :: Char -> Int
+ord  =  fromEnum
+     
+chr  :: Int  -> Char
+chr  =  toEnum
 
 -- Text functions
-readLitChar             :: ReadS Char
-readLitChar ('\\':s)    =  readEsc s
-        where
-        readEsc ('a':s)  = [('\a',s)]
-        readEsc ('b':s)  = [('\b',s)]
-        readEsc ('f':s)  = [('\f',s)]
-        readEsc ('n':s)  = [('\n',s)]
-        readEsc ('r':s)  = [('\r',s)]
-        readEsc ('t':s)  = [('\t',s)]
-        readEsc ('v':s)  = [('\v',s)]
-        readEsc ('\\':s) = [('\\',s)]
-        readEsc ('"':s)  = [('"',s)]
-        readEsc ('\'':s) = [('\'',s)]
-        readEsc ('^':c:s) | c >= '@' && c <= '_'
-                         = [(chr (ord c - ord '@'), s)]
-        readEsc s@(d:_) | isDigit d
-                         = [(chr n, t) | (n,t) <- readDec s]
-        readEsc ('o':s)  = [(chr n, t) | (n,t) <- readOct s]
-        readEsc ('x':s)  = [(chr n, t) | (n,t) <- readHex s]
-        readEsc s@(c:_) | isUpper c
-                         = let table = ('\DEL', "DEL") : assocs asciiTab
-                           in case [(c,s') | (c, mne) <- table,
-                                             ([],s') <- [match mne s]]
-                              of (pr:_) -> [pr]
-                                 []     -> []
-        readEsc _        = []
-
-       match                         :: (Eq a) => [a] -> [a] -> ([a],[a])
-       match (x:xs) (y:ys) | x == y  =  match xs ys
-       match xs     ys               =  (xs,ys)
-
-readLitChar (c:s)       =  [(c,s)]
+readLitChar          :: ReadS Char
+readLitChar ('\\':s) =  readEsc s
+readLitChar (c:s)    =  [(c,s)]
+
+readEsc          :: ReadS Char
+readEsc ('a':s)  = [('\a',s)]
+readEsc ('b':s)  = [('\b',s)]
+readEsc ('f':s)  = [('\f',s)]
+readEsc ('n':s)  = [('\n',s)]
+readEsc ('r':s)  = [('\r',s)]
+readEsc ('t':s)  = [('\t',s)]
+readEsc ('v':s)  = [('\v',s)]
+readEsc ('\\':s) = [('\\',s)]
+readEsc ('"':s)  = [('"',s)]
+readEsc ('\'':s) = [('\'',s)]
+readEsc ('^':c:s) | c >= '@' && c <= '_'
+                 = [(chr (ord c - ord '@'), s)]
+readEsc s@(d:_) | isDigit d
+                 = [(chr n, t) | (n,t) <- readDec s]
+readEsc ('o':s)  = [(chr n, t) | (n,t) <- readOct s]
+readEsc ('x':s)  = [(chr n, t) | (n,t) <- readHex s]
+readEsc s@(c:_) | isUpper c
+                 = let table = ('\DEL', "DEL") : assocs asciiTab
+                   in case [(c,s') | (c, mne) <- table,
+                                     ([],s') <- [match mne s]]
+                      of (pr:_) -> [pr]
+                         []     -> []
+readEsc _        = []
+
+match                         :: (Eq a) => [a] -> [a] -> ([a],[a])
+match (x:xs) (y:ys) | x == y  =  match xs ys
+match xs     ys               =  (xs,ys)
 
 showLitChar               :: Char -> ShowS
 showLitChar c | c > '\DEL' =  showChar '\\' . 
@@ -135,15 +135,22 @@ asciiTab = listArray ('\NUL', ' ')
             "SP"] 
 
 lexLitChar          :: ReadS String
-lexLitChar ('\\':s) =  [('\\':esc, t) | (esc,t) <- lexEsc s]
+lexLitChar ('\\':s) =  map (prefix '\\') (lexEsc s)
         where
           lexEsc (c:s)     | c `elem` "abfnrtv\\\"'" = [([c],s)]
-          lexEsc s@(d:_)   | isDigit d               = lexDigits s
           lexEsc ('^':c:s) | c >= '@' && c <= '_'    = [(['^',c],s)]
-          -- Very crude approximation to \XYZ.  Let readers work this out.
-          lexEsc s@(c:_)   | isUpper c               = [span isCharName s]
-          lexEsc _                                   = []
-          isCharName c = isUpper c || isDigit c
+
+          -- Numeric escapes
+          lexEsc ('o':s)               = [prefix 'o' (span isOctDigit s)]
+          lexEsc ('x':s)               = [prefix 'x' (span isHexDigit s)]
+          lexEsc s@(d:_)   | isDigit d = [span isDigit s]
+
+          -- Very crude approximation to \XYZ.
+          lexEsc s@(c:_)   | isUpper c = [span isCharName s]
+          lexEsc _                     = []
+
+          isCharName c   = isUpper c || isDigit c
+          prefix c (t,s) = (c:t, s)
 
 lexLitChar (c:s)    =  [([c],s)]
 lexLitChar ""       =  []
index d70b192..6c29939 100644 (file)
@@ -1,6 +1,6 @@
 module IO {- export list omitted -} where
 
--- Just provide an implementation of the system-indendent
+-- Just provide an implementation of the system-independent
 -- actions that IO exports.
 
 try            :: IO a -> IO (Either IOError a)
index 3e52866..e379aac 100644 (file)
@@ -1,6 +1,6 @@
-module Ix ( Ix(range, index, inRange), rangeSize ) where
+module Ix ( Ix(range, index, inRange, rangeSize) ) where
 
-class  Ix a  where
+class  Ord a => Ix a  where
     range     :: (a,a) -> [a]
     index     :: (a,a) -> a -> Int
     inRange   :: (a,a) -> a -> Bool
index 918f3c6..9dcf496 100644 (file)
@@ -313,7 +313,7 @@ floatToDigits base x =
 -- This floating point reader uses a less restrictive syntax for floating
 -- point than the Haskell lexer.  The `.' is optional.
 
-readFloat     :: (RealFloat a) => ReadS a
+readFloat     :: (RealFrac a) => ReadS a
 readFloat r    = [(fromRational ((n%1)*10^^(k-d)),t) | (n,d,s) <- readFix r,
                                                        (k,t)   <- readExp s] ++
                  [ (0/0, t) | ("NaN",t)      <- lex r] ++
index 7438eb9..10b0c84 100644 (file)
@@ -5,7 +5,7 @@ module  Ratio (
 
 infixl 7  %
 
-prec = 7 :: Int
+ratPrec = 7 :: Int
 
 data  (Integral a)      => Ratio a = !a :% !a  deriving (Eq)
 type  Rational          =  Ratio Integer
@@ -58,6 +58,8 @@ instance  (Integral a)  => RealFrac (Ratio a)  where
                             where (q,r) = quotRem x y
 
 instance  (Integral a)  => Enum (Ratio a)  where
+    succ x           =  x+1
+    pred x           =  x-1
     toEnum           =  fromIntegral
     fromEnum         =  fromInteger . truncate -- May overflow
     enumFrom         =  numericEnumFrom                -- These numericEnumXXX functions
@@ -66,14 +68,16 @@ instance  (Integral a)  => Enum (Ratio a)  where
     enumFromThenTo   =  numericEnumFromThenTo
 
 instance  (Read a, Integral a)  => Read (Ratio a)  where
-    readsPrec p  =  readParen (p > prec)
-                              (\r -> [(x%y,u) | (x,s)   <- reads r,
+    readsPrec p  =  readParen (p > ratPrec)
+                              (\r -> [(x%y,u) | (x,s)   <- readsPrec (ratPrec+1) r,
                                                 ("%",t) <- lex s,
-                                                (y,u)   <- reads t ])
+                                                (y,u)   <- readsPrec (ratPrec+1) t ])
 
 instance  (Integral a)  => Show (Ratio a)  where
-    showsPrec p (x:%y)  =  showParen (p > prec)
-                               (shows x . showString " % " . shows y)
+    showsPrec p (x:%y)  =  showParen (p > ratPrec)
+                               (showsPrec (ratPrec+1) x . 
+                               showString " % " . 
+                               showsPrec (ratPrec+1) y)
 
 
 
index 10ff718..ac5199d 100644 (file)
@@ -1,6 +1,6 @@
-module Ix ( Ix(range, index, inRange), rangeSize ) where
+module Ix ( Ix(range, index, inRange, rangeSize) ) where
 
-class  Ix a  where
+class  Ord a => Ix a  where
     range       :: (a,a) -> [a]
     index       :: (a,a) -> a -> Int
     inRange     :: (a,a) -> a -> Bool
index 9cd98d9..04e6710 100644 (file)
@@ -29,5 +29,5 @@ showFloat      :: (RealFloat a) => a -> ShowS
 
 floatToDigits  :: (RealFloat a) => Integer -> a -> ([Int], Int)
 
-readFloat      :: (RealFloat a) => ReadS a
+readFloat      :: (RealFrac a) => ReadS a
 lexDigits      :: ReadS String 
index d1f589d..668b0d6 100644 (file)
@@ -33,7 +33,7 @@ style=article
 ~back=<a href="~prev.html">back</a>
 ~nxt=<a href="~next.html">next</a>
 ~contents=<a href="libindex.html">contents</a>
-~foot=<br><font size=2>December 2001</font>
+~foot=<br><font size=2>Sept 2002</font>
 ~footer=<hr>~id~top | ~back | ~nxt | ~contents ~foot
 ~sfooter=<hr>~id~top | back | ~nxt | ~contents ~foot
 ~efooter=<hr>~id~top | ~back | next | ~contents ~foot
index 62c32c4..053ca7f 100644 (file)
@@ -7,7 +7,7 @@
 <img src="h98-libs.gif" alt="Haskell 98 Libraries">
 
 <h3 align="center">Standard Libraries for Haskell 98</h3>
-<h3 align="center">Revised: December 2001</h3>
+<h3 align="center">Revised: Sept 2002</h3>
 </div>
 <hr>
 <h3>Table of Contents</h3>
index 4af659f..b08af4d 100644 (file)
@@ -33,6 +33,7 @@ including
 Olaf Chitil,
 Mark Carroll,
 Tony Davie,
+Hal Daume,
 Sigbjorn Finne,
 Andy Gill, 
 Mike Gunter,
index db48fb3..a4f6846 100644 (file)
@@ -259,7 +259,9 @@ permission to open the file.
 Computation @hClose@~"hdl"\indextt{hClose} makes handle "hdl" closed.  Before the
 computation finishes, if "hdl" is writable its buffer is flushed as
 for @hFlush@.
-If the operation fails for any reason, any further operations on the 
+Performing @hClose@ on a handle that has already been closed has no effect; 
+doing so not an error.  All other operations on a closed handle will fail.
+If @hClose@ fails for any reason, any further operations (apart from @hClose@) on the 
 handle will still fail as if "hdl" had been successfully closed.
 
 \subsection{Determining the Size of a File}
@@ -478,16 +480,27 @@ within "t" milliseconds.
 Computation @hReady@~"hdl"\indextt{hReady} indicates whether at least one item is
 available for input from handle "hdl".
 
+{\em Error reporting}.
+The @hWaitForInput@ and @hReady@ computations fail with
+@isEOFError@ if the end of file has been reached.
+
+\subsubsection{Reading Input}
+
 Computation @hGetChar@~"hdl"\indextt{hGetChar} reads a character from
 the file or channel managed by "hdl".
 
-Computation @hGetLine@~"hdl"\indextt{hGetLine} reads a line from
-the file or channel managed by "hdl", similar to @getLine@ in the
-Prelude. 
-
-{\em Error reporting}:
-the @hWaitForInput@, @hReady@ and @hGetChar@ computations may fail with:
+Computation @hGetLine@~"hdl"\indextt{hGetLine} reads a line from the file or
+channel managed by "hdl". The Prelude's @getLine@ is a shorthand
+for @hGetLine stdin@.
+{\em Error reporting}.
+The @hGetChar@ computation fails with
 @isEOFError@ if the end of file has been reached.
+The @hGetLine@ fails with @isEOFError@ if the end of file is encountered
+when reading the {\em first} character of the line. If @hGetLine@ encounters
+end-of-file at any other point while reading in a line, it is treated as
+a line terminator and the (partial) line is returned.
+
 
 \subsubsection{Reading Ahead}
 \label{hLookAhead}
index 8161174..53e8b57 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/libraries/library.verb,v 1.12 2001/12/21 16:00:22 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/libraries/library.verb,v 1.13 2002/12/02 11:22:00 simonpj Exp $
 %
 % NOTE:--------------------------------------------------------------
 % The formatting of this report and the ``new font selection scheme''
 {\Large\bf for the} \\[.1in]
 {\huge\bf Haskell 98} \\[.3in]
 {\LARGE\bf Programming Language} \\[.3in]
-{\large\bf Revised: December 2001}
+{\large\bf Revised: Sept 2002}
 \end{center}
 
 \vspace{.15in}
index 018e829..72d57f9 100644 (file)
@@ -32,8 +32,9 @@ or Nothing, if there is no such element.
 
 There are a number of ``set'' operations defined over the @List@ type.
 @nub@ (meaning ``essence'') removes duplicates elements from a list.
-@delete@, @(\\)@, @union@ and @intersect@ preserve the invariant that 
-lists don't contain duplicates, provided that their first argument
+@delete@, @(\\)@, @union@ and @intersect@ (and their @By@ variants) 
+preserve the invariant their result
+does not contain duplicates, provided that their first argument
 contains no duplicates.
 
 \begin{itemize}
@@ -72,7 +73,7 @@ has been removed from @xs@.  Thus, @(xs ++ ys) \\ xs == ys@.
 @intersect@\indextt{intersect} is list intersection, e.g.,  
 \bprog
 @
-  intersect [1,2,3,4] `intersect` [2,4,6,8] == [2,4]
+  [1,2,3,4] `intersect` [2,4,6,8] == [2,4]
 @
 \eprog
 \end{itemize}
@@ -194,18 +195,18 @@ counterpart whose name is suffixed with ``@By@''.  For example, the
 function @nub@ could be defined as follows:
 \bprog
 @
-  nub                     :: (Eq a) => [a] -> [a]
-  nub []                  =  []
-  nub (x:xs)              =  x : nub (filter (\y -> x /= y) xs)
+  nub              :: (Eq a) => [a] -> [a]
+  nub []           =  []
+  nub (x:xs)       =  x : nub (filter (\y -> not (x == y)) xs)
 @
 \eprog
 However, the equality method may not be appropriate in all situations.
 The function:
 \bprog
 @
-  nubBy                   :: (a -> a -> Bool) -> [a] -> [a]
-  nubBy eq []             =  []
-  nubBy eq (x:xs)         =  x : nubBy eq (filter (\y -> not (eq x y)) xs)
+  nubBy            :: (a -> a -> Bool) -> [a] -> [a]
+  nubBy eq []      =  []
+  nubBy eq (x:xs)  =  x : nubBy eq (filter (\y -> not (eq x y)) xs)
 @
 \eprog
 allows the programmer to supply their own equality test.
@@ -249,7 +250,7 @@ a generalised version of a @Prelude@ function.  For example,
   genericLength       :: Integral a => [b] -> a
 @ 
 \eprog
-is a generalised verion of @length@.
+is a generalised version of @length@.
 
 The ``@generic@'' operations are as follows:
 @genericLength@, @genericTake@, @genericDrop@,
index 4c05521..02c2f6a 100644 (file)
@@ -67,13 +67,19 @@ then the following properties hold:
 \item @readSigned :: (Real a) => ReadS a -> ReadS a@ \\ 
 reads a {\em signed} @Real@ value,
 given a reader for an unsigned value.
-\item @readInt :: (Integral a) => a -> (Char->Bool) -> (Char->Int) -> ReadS a@
+
+\item @readInt :: (Integral a) => a -> (Char->Bool) -> (Char->Int) -> ReadS a@ \\
 reads an {\em unsigned} @Integral@ value in an arbitrary base.  In the call "(@readInt@~ base ~isdig ~d2i)",
 "base" is the base, "isdig" is a predicate distinguishing valid digits in this base, and "d2i" converts
 a valid digit character to an @Int@.
+
+\item @readFloat :: (RealFrac a) => ReadS a@ \\ 
+reads an {\em unsigned} @RealFrac@ value, expressed in decimal scientific notation.
+
 \item @readDec, readOct, readHex :: (Integral a) => ReadS a@  \\
 each read an unsigned number, in decimal, octal, and hexadecimal notation respectively.
 In the hexadecimal case, both upper or lower case letters are allowed.
+
 \item @lexDigits :: ReadS String@ reads a non-empty string of decimal digits.
 \end{itemize}
 (NB: @readInt@ is the ``dual'' of @showIntAtBase@, and @readDec@ is the ``dual'' of @showInt@.
index 00b29b6..2455ab9 100644 (file)
@@ -1,10 +1,13 @@
 # Makefile for the Haskell Report
 # read the README file before you start!
+#
+#      Target 'jfp' copies stuff into $(JFP_DIR) for the JFP book
+#      you need to do the same in the libraries directory
 
 ##########################################
 # What to make if you type 'make'
 
-default: haskell.ps.gz html
+default: haskell.ps html
 
 # Begin by saying
 #      touch haskell.idx
@@ -38,8 +41,10 @@ EXPAND = expand
 #########################################
 
 RELEASE_DIR = ../haskell98-revised
+JFP_DIR = ../jfp-release
 
-PARTS =                preface-13.tex iso-chars.tex \
+PARTS =                preface-jfp.tex $(PARTS_NO_PREFACE)
+PARTS_NO_PREFACE = iso-chars.tex \
                intro.tex lexemes.tex  exps.tex \
                decls.tex  modules.tex  basic.tex  io-13.tex \
                derived.tex \
@@ -162,6 +167,14 @@ release: haskell.ps html
 publish-pdf: report.pdf
        gzip < report.pdf > y:Haskell/haskell98-report/report.pdf.gz
 
+jfp: h98-book.tex preface-jfp.tex ${PARTS_NO_PREFACE} $(SYNTAX) ${PRELUDE}
+       -mkdir $(JFP_DIR)
+       for n in h98-book.tex preface-jfp.tex \
+               ${PARTS_NO_PREFACE} $(SYNTAX) ${PRELUDE} ; do  \
+               ../tools/subsection < $$n >  $(JFP_DIR)/$$n ; done 
+       cp classes.eps $(JFP_DIR)
+       cp  haskell.bbl $(JFP_DIR)/h98-book.bbl
+       cp Makefile-jfp-book $(JFP_DIR)/Makefile
 
 #########################################
 #      Suffix rules
index b9cd32b..2aa0e07 100644 (file)
@@ -525,7 +525,7 @@ numericEnumFromThen n m =  iterate (+(m-n)) n
 numericEnumFromTo n m   =  takeWhile (<= m+1/2) (numericEnumFrom n)
 numericEnumFromThenTo n n' m = takeWhile p (numericEnumFromThen n n')
                              where
-                               p | n' > n    = (<= m + (n'-n)/2)
+                               p | n' >= n   = (<= m + (n'-n)/2)
                                  | otherwise = (>= m + (n'-n)/2)
 
 -- Lists
index 3050dc9..99ebcc0 100644 (file)
@@ -6,7 +6,7 @@ module PreludeText (
     showChar, showString, readParen, showParen ) where
 
 -- The instances of Read and Show for
---      Bool, Char, Maybe, Either, Ordering
+--      Bool, Maybe, Either, Ordering
 -- are done via "deriving" clauses in Prelude.hs
 
 import Char(isSpace, isAlpha, isDigit, isAlphaNum,
@@ -147,13 +147,13 @@ instance  Show Float  where
     showsPrec p         = showFloat
            
 instance  Read Float  where
-    readsPrec p         = readFloat
+    readsPrec p         = readSigned readFloat
 
 instance  Show Double  where
     showsPrec p         = showFloat
 
 instance  Read Double  where
-    readsPrec p         = readFloat
+    readsPrec p         = readSigned readFloat
 
 instance  Show ()  where
     showsPrec p () = showString "()"
index a570bcb..319e56b 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/basic.verb,v 1.11 2001/12/21 16:00:24 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/basic.verb,v 1.12 2002/12/02 11:22:01 simonpj Exp $
 %
 %**<title>The Haskell 98 Report: Basic Types and Classes</title>
 %*section 6
@@ -236,7 +236,8 @@ not the same as @\x -> @ "\bot", since @seq@ can be used to distinguish them.
 For the same reason, the existence of @seq@ weakens Haskell's parametricity properties.
 
 The operator @$!@ is strict (call-by-value) application, and is defined
-in terms of @seq@.  The Prelude also defines the @$@ operator to perform lazy application.
+in terms of @seq@.  The Prelude also defines the @$@ operator to perform 
+non-strict application.
 \bprog
 @
   infixr 0 $, $!
@@ -245,7 +246,7 @@ in terms of @seq@.  The Prelude also defines the @$@ operator to perform lazy ap
    f $! x   =  x `seq` f x
 @
 \eprog
-The lazy application operator @$@ may appear redundant, since 
+The non-strict application operator @$@ may appear redundant, since 
 ordinary application @(f x)@ means the same as @(f $ x)@.
 However, @$@ has low, right-associative binding precedence,
 so it sometimes allows parentheses to be omitted; for example:
@@ -431,7 +432,16 @@ read s  =  case [x | (x,t) <- reads s, ("","") <- lex t] of
 \indextt{shows}\indextt{reads}\indextt{show}\indextt{read}
 @shows@ and @reads@ use a default precedence of 0.  The @read@ function reads
 input from a string, which must be completely consumed by the input
-process.  The @lex@ function used by @read@ is also part of the Prelude.
+process.  
+
+\indextt{lex}
+The function @lex :: ReadS String@, used by @read@, is also part of the Prelude.
+It reads a single lexeme from the input, discarding initial white space, and
+returning the characters that constitute the lexeme.  If the input string contains
+only white space, @lex@ returns a single successful ``lexeme'' consisting of the
+empty string.  (Thus @lex ""@ = @[("","")]@.)  If there is no legal lexeme at the
+beginning of the input string, @lex@ fails (i.e. returns @[]@).
+
 
 \subsubsection{The Enum Class}
 \label{enum-class}
@@ -539,7 +549,7 @@ when the elements become greater than "e_3+i/2" for positive increment
 For all four of these Prelude numeric types, all of the @enumFrom@ 
 family of functions are strict in all their arguments.
 
-\subsubsection{Class @Functor@}
+\subsubsection{The Functor Class}
 \indexclass{Functor}
 \indextt{fmap}
 \index{functor}
@@ -547,7 +557,7 @@ family of functions are strict in all their arguments.
 \bprog
 @
 class  Functor f  where
-    fmap    :: (a -> b) -> (f a -> f b)
+    fmap    :: (a -> b) -> f a -> f b
 @
 \eprog
 The @Functor@
@@ -562,7 +572,7 @@ Instances of @Functor@ should satisfy the following laws:
 All instances of @Functor@ defined in the Prelude satisfy these laws.
 
 
-\subsubsection{Class @Monad@}
+\subsubsection{The Monad Class}
 \label{monad-class}
 \indexclass{Monad}
 \indextt{return}
index ef57123..865a5c1 100644 (file)
@@ -1,20 +1,21 @@
 %!PS-Adobe-3.0 EPSF-3.0
 %%Title: Microsoft PowerPoint - classes.ppt
-%%Creator: Pscript.dll Version 5.0
-%%CreationDate: 8/15/2001 16:52:23
-%%BoundingBox: 95 150 503 681
+%%Creator: PScript5.dll Version 5.2
+%%CreationDate: 4/22/2002 16:28:25
+%%BoundingBox: 95 150 503 680
 %%Pages: 1
 %%Orientation: Portrait
 %%PageOrder: Ascend
 %%DocumentNeededResources: (atend)
 %%DocumentSuppliedResources: (atend)
 %%DocumentData: Clean7Bit
-%%TargetDevice: (HP LaserJet 4000 Series) (2014.108) 1
-%%LanguageLevel: 2
+%%TargetDevice: (Xerox Document Centre 432/440ST) (3010.106) 2200
+%%LanguageLevel: 3
 %%EndComments
 
 %%BeginDefaults
-%%PageBoundingBox: 14 13 581 828
+%%PageBoundingBox: 12 12 583 830
+%%ViewingOrientation: 1 0 0 1
 %%EndDefaults
 
 %%BeginProlog
@@ -42,22 +43,23 @@ rcheck{dup xcheck{({)tprint{typeprint}forall(})tprint}{([)tprint{typeprint}
 forall(])tprint}ifelse}{pop(-packedarray- )tprint}ifelse}readonly def/courier
 /Courier findfont 10 scalefont def end errordict/handleerror{systemdict begin
 $error begin $brkpage begin newerror{/newerror false store vmstatus pop pop 0
-ne{grestoreall}if showpage initgraphics courier setfont lmargin 720 moveto
-errorname(VMError)eq{PrtVMMsg}{(ERROR: )prnt errorname prnt nl
-(OFFENDING COMMAND: )prnt/command load prnt $error/ostack known{nl nl(STACK:)
-prnt nl nl $error/ostack get aload length{==}repeat}if}ifelse systemdict
-/showpage get exec(%%[ Error: )print errorname =print(; OffendingCommand: )
-print/command load =print( ]%%)= flush}if end end end}dup 0 systemdict put dup
-4 $brkpage put bind readonly put/currentpacking where{pop/setpacking where{pop
-oldpack setpacking}if}if
+ne{grestoreall}if errorname(VMerror)ne{showpage}if initgraphics courier setfont
+lmargin 720 moveto errorname(VMerror)eq{userdict/ehsave known{clear userdict
+/ehsave get restore 2 vmreclaim}if vmstatus exch pop exch pop PrtVMMsg}{
+(ERROR: )prnt errorname prnt nl(OFFENDING COMMAND: )prnt/command load prnt
+$error/ostack known{nl nl(STACK:)prnt nl nl $error/ostack get aload length{==}
+repeat}if}ifelse systemdict/showpage get exec(%%[ Error: )print errorname
+=print(; OffendingCommand: )print/command load =print( ]%%)= flush}if end end
+end}dup 0 systemdict put dup 4 $brkpage put bind readonly put/currentpacking
+where{pop/setpacking where{pop oldpack setpacking}if}if
 %%EndResource
 userdict /Pscript_WinNT_Incr 230 dict dup begin put
 %%BeginResource: file Pscript_FatalError 5.0 0
-/FatalErrorIf{{initgraphics findfont 1 index 0 eq{exch pop}{dup length dict
-begin{1 index/FID ne{def}{pop pop}ifelse}forall/Encoding{ISOLatin1Encoding}
-stopped{StandardEncoding}if def currentdict end/ErrFont-Latin1 exch definefont}
-ifelse exch scalefont setfont counttomark 3 div cvi{moveto show}repeat showpage
-quit}{cleartomark}ifelse}bind def
+userdict begin/FatalErrorIf{{initgraphics findfont 1 index 0 eq{exch pop}{dup
+length dict begin{1 index/FID ne{def}{pop pop}ifelse}forall/Encoding
+{ISOLatin1Encoding}stopped{StandardEncoding}if def currentdict end
+/ErrFont-Latin1 exch definefont}ifelse exch scalefont setfont counttomark 3 div
+cvi{moveto show}repeat showpage quit}{cleartomark}ifelse}bind def end
 %%EndResource
 userdict begin/PrtVMMsg{vmstatus exch sub exch pop gt{[
 (This job requires more memory than is available in this printer.)100 500
@@ -82,21 +84,27 @@ d}if/b{bind d}bind d/bd{bind d}bind d/xd{~ d}bd/ld{, d}bd/bn/bind ld/lw/Lw ld
 /lc/Lc ld/lj/Lj ld/sg/setgray ld/ADO_mxRot null d/self & d/OrgMx matrix
 currentmatrix d/reinitialize{: OrgMx setmatrix[/TextInit/GraphInit/UtilsInit
 counttomark{@ where{self eq}{F}?{cvx exec}{!}?}repeat cleartomark ;}b
-/initialize{`{/ADO_mxRot ~ d/TextInitialised? F d reinitialize E}{U
-/Pscript_Win_Data 230 dict @ ` put/ADO_mxRot ~ d/TextInitialised? F d
-reinitialize}?}b/terminate{!{& self eq{exit}{E}?}loop E}b/suspend/terminate , d
-/resume{` Pscript_Win_Data `}b U `/lucas 21690 d/featurebegin{countdictstack
-lucas[}b/featurecleanup{stopped{cleartomark @ lucas eq{! exit}if}loop
-countdictstack ~ sub @ 0 gt{{E}repeat}{!}?}b E/snap{transform 0.25 sub round
-0.25 add ~ 0.25 sub round 0.25 add ~ itransform}b/dsnap{dtransform round ~
-round ~ idtransform}b/nonzero_round{@ 0.5 ge{round}{@ -0.5 lt{round}{0 ge{1}
-{-1}?}?}?}b/nonzero_dsnap{dtransform nonzero_round ~ nonzero_round ~
-idtransform}b U<04>cvn{}put/rr{1 ^ 0 - 0 ~ - neg 0 - C}b/irp{4 -2 $ + +S fx 4 2
-$ M 1 ^ 0 - 0 ~ - neg 0 -}b/rp{4 2 $ M 1 ^ 0 - 0 ~ - neg 0 -}b/solid{[]0 sd}b/g
-{@ not{U/DefIf_save save put}if U/DefIf_bool 2 ^ put}b/DefIf_El{if U/DefIf_bool
-get not @{U/DefIf_save get restore}if}b/e{DefIf_El !}b/UDF{L2?{undefinefont}{!}
-?}b/UDR{L2?{undefineresource}{! !}?}b/freeVM{/Courier findfont[40 0 0 -40 0 0]
-makefont Ji 2 vmreclaim}b
+/initialize{`{/Pscript_Win_Data where{!}{U/Pscript_Win_Data & put}?/ADO_mxRot ~
+d/TextInitialised? F d reinitialize E}{U/Pscript_Win_Data 230 dict @ ` put
+/ADO_mxRot ~ d/TextInitialised? F d reinitialize}?}b/terminate{!{& self eq
+{exit}{E}?}loop E}b/suspend/terminate , d/resume{` Pscript_Win_Data `}b U `
+/lucas 21690 d/featurebegin{countdictstack lucas[}b/featurecleanup{stopped
+{cleartomark @ lucas eq{! exit}if}loop countdictstack ~ sub @ 0 gt{{E}repeat}
+{!}?}b E/snap{transform 0.25 sub round 0.25 add ~ 0.25 sub round 0.25 add ~
+itransform}b/dsnap{dtransform round ~ round ~ idtransform}b/nonzero_round{@ 0.5
+ge{round}{@ -0.5 lt{round}{0 ge{1}{-1}?}?}?}b/nonzero_dsnap{dtransform
+nonzero_round ~ nonzero_round ~ idtransform}b U<04>cvn{}put/rr{1 ^ 0 - 0 ~ -
+neg 0 - C}b/irp{4 -2 $ + +S fx 4 2 $ M 1 ^ 0 - 0 ~ - neg 0 -}b/rp{4 2 $ M 1 ^ 0
+- 0 ~ - neg 0 -}b/solid{[]0 sd}b/g{@ not{U/DefIf_save save put}if U/DefIf_bool
+2 ^ put}b/DefIf_El{if U/DefIf_bool get not @{U/DefIf_save get restore}if}b/e
+{DefIf_El !}b/UDF{L2?{undefinefont}{!}?}b/UDR{L2?{undefineresource}{! !}?}b
+/freeVM{/Courier findfont[40 0 0 -40 0 0]makefont Ji 2 vmreclaim}b/hfRedefFont
+{findfont @ length dict `{1 ^/FID ne{d}{! !}?}forall & E @ ` ~{/CharStrings 1
+dict `/.notdef 0 d & E d}if/Encoding 256 array 0 1 255{1 ^ ~/.notdef put}for d
+E definefont !}bind d/hfMkCIDFont{/CIDFont findresource @ length 2 add dict `{1
+^ @/FID eq ~ @/XUID eq ~/UIDBase eq or or{! !}{d}?}forall/CDevProc ~ d/Metrics2
+16 dict d/CIDFontName 1 ^ d & E 1 ^ ~/CIDFont defineresource ![~]composefont !}
+bind d
 %%EndResource
 %%BeginResource: file Pscript_Win_Utils_L2 5.0 0
 /rf/rectfill , d/fx{1 1 dtransform @ 0 ge{1 sub 0.5}{1 add -0.5}? 3 -1 $ @ 0 ge
@@ -120,7 +128,12 @@ getinterval}repeat ! cvn 3 1 $ ! ! E}b/definecolorrendering{~ buildcrdname ~
 /findcolorrendering{buildcrdname @/ColorRendering resourcestatus{! ! T}{
 /ColorRendering/ProcSet findresource ` GetSubstituteCRD E F}?}b}?
 /selectcolorrendering{findcolorrendering !/ColorRendering findresource
-setcolorrendering}b
+setcolorrendering}b/G2UBegin{findresource/FontInfo get/GlyphNames2Unicode get
+`}bind d/G2CCBegin{findresource/FontInfo get/GlyphNames2HostCode get `}bind d
+/G2UEnd{E}bind d/AddFontInfoBegin{/FontInfo 8 dict @ `}bind d/AddFontInfo{
+/GlyphNames2Unicode 16 dict d/GlyphNames2HostCode 16 dict d}bind d
+/AddFontInfoEnd{E d}bind d/T0AddCFFMtx2{/CIDFont findresource/Metrics2 get ` d
+E}bind d
 %%EndResource
 end
 %%EndProlog
@@ -128,11 +141,11 @@ end
 %%BeginSetup
 [ 1 0 0 1 0 0 ] false Pscript_WinNT_Incr dup /initialize get exec
 1 setlinecap 1 setlinejoin
-/mysetup [ 0.11999 0 0 -0.11999 14.00031 828 ] def 
+/mysetup [ 72 600 V 0 0 -72 600 V 11.99905 830.00128 ] def 
 %%EndSetup
 
 %%Page: 1 1
-%%PageBoundingBox: 14 13 581 828
+%%PageBoundingBox: 12 12 583 830
 %%EndPageComments
 %%BeginPageSetup
 /DeviceRGB dup setcolorspace /colspABC exch def
@@ -184,18 +197,18 @@ Pscript_WinNT_Compat dup /initialize get exec
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 NP
-502 996 m 4222 996 l 4222 5796 l 502 5796 l CP
+519 1008 m 4239 1008 l 4239 5808 l 519 5808 l CP
 eoclip
 1 1 1 SC
 NP
-501 995 m 4221 995 l 4221 5796 l 501 5796 l CP
+518 1007 m 4238 1007 l 4238 5808 l 518 5808 l CP
 AF
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1331 1365 m 1078 1365 873 1471 873 1602 c 873 1733 1078 1839 1331 1839 c 1583 1839 1788 1733 1788 1602 c 1788 1471 1583 1365 1331 1365 c CP
+1348 1377 m 1095 1377 890 1483 890 1614 c 890 1745 1095 1851 1348 1851 c 1600 1851 1805 1745 1805 1614 c 1805 1483 1600 1377 1348 1377 c CP
 S
 GSE
 
@@ -203,8 +216,8 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol Pscript_WinNT_Incr begin
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol Pscript_WinNT_Incr begin
 %%BeginResource: file Pscript_Text 5.0 0
 /TextInit{TextInitialised? not{/Pscript_Windows_Font & d/TextInitialised? T d
 /fM[1 0 0 1 0 0]d/mFM matrix d/iMat[1 0 0.212557 1 0 0]d}if}b/copyfont{1 ^
@@ -233,11 +246,12 @@ length 1 sub{@ @ 10 lt{! FontName length 1 add string}{100 lt{FontName length 2
 add string}{FontName length 3 add string}?}? @ 0 FontName @ length string cvs
 putinterval @ 3 -1 $ @ 4 1 $ 3 string cvs FontName length ~ putinterval cvn 1 ^
 256 mul @ 255 add 3 -1 $ 4 ^ findfont mF42D FDepVector 3 1 $ put}for & @ E
-/FontName get ~ definefont ! ! ! mF}b/mF_OTF_V{3{~ !}repeat 3 -1 $ ! findfont 1
-^ ~ definefont fM @ @ 5 0 put 4 0 put 90 matrix R matrix concatmatrix makefont
-Pscript_Windows_Font 3 1 $ put}b/UmF{L2?{Pscript_Windows_Font ~ undef}{!}?}b
-/UmF42{@ findfont/FDepVector get{/FontName get undefinefont}forall
-undefinefont}b
+/FontName get ~ definefont ! ! ! mF}b/mF_OTF_V{~ ! ~ ! 4 -1 $ ! findfont 2 ^ ~
+definefont fM @ @ 4 6 -1 $ neg put 5 0 put 90 matrix R matrix concatmatrix
+makefont Pscript_Windows_Font 3 1 $ put}b/mF_TTF_V{3{~ !}repeat 3 -1 $ !
+findfont 1 ^ ~ definefont Pscript_Windows_Font 3 1 $ put}b/UmF{L2?
+{Pscript_Windows_Font ~ undef}{!}?}b/UmF42{@ findfont/FDepVector get{/FontName
+get undefinefont}forall undefinefont}b
 %%EndResource
 end reinitialize
 Pscript_WinNT_Incr begin
@@ -245,7 +259,7 @@ Pscript_WinNT_Incr begin
 /CharCol256Encoding[/.notdef/breve/caron/dotaccent/dotlessi/fi/fl/fraction
 /hungarumlaut/Lslash/lslash/minus/ogonek/ring/Zcaron/zcaron/.notdef/.notdef
 /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef
-/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/exclam/quotedbl/numbersign
+/.notdef/.notdef/.notdef/.notdef/.notdef/space/exclam/quotedbl/numbersign
 /dollar/percent/ampersand/quotesingle/parenleft/parenright/asterisk/plus/comma
 /hyphen/period/slash/zero/one/two/three/four/five/six/seven/eight/nine/colon
 /semicolon/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S
@@ -271,18 +285,105 @@ Pscript_WinNT_Incr begin
 end reinitialize
 
 %%IncludeResource: font Courier-Bold
+Pscript_WinNT_Incr begin
+%%BeginResource: file Pscript_Win_Euro_L2 5.0 0
+/UseT3EuroFont{/currentdistillerparams where{pop currentdistillerparams
+/CoreDistVersion get 4000 le}{false}ifelse}bind def/NewEuroT3Font?{dup/FontType
+get 3 eq{dup/EuroFont known exch/BaseFont known and}{pop false}ifelse}bind def
+/T1FontHasEuro{dup/CharStrings known not{dup NewEuroT3Font?{dup/EuroGlyphName
+get exch/EuroFont get/CharStrings get exch known{true}{false}ifelse}{pop false}
+ifelse}{dup/FontType get 1 eq{/CharStrings get/Euro known}{dup/InfoDict known{
+/InfoDict get/Euro known}{/CharStrings get/Euro known}ifelse}ifelse}ifelse}bind
+def/FontHasEuro{findfont dup/Blend known{pop true}{T1FontHasEuro}ifelse}bind
+def/EuroEncodingIdx 1 def/EuroFontHdr{12 dict begin/FontInfo 10 dict dup begin
+/version(001.000)readonly def/Notice(Copyright (c)1999 Adobe Systems
+Incorporated. All Rights Reserved.)readonly def/FullName(Euro)readonly def
+/FamilyName(Euro)readonly def/Weight(Regular)readonly def/isFixedPitch false
+def/ItalicAngle 0 def/UnderlinePosition -100 def/UnderlineThickness 50 def end
+readonly def/FontName/Euro def/Encoding 256 array 0 1 255{1 index exch/.notdef
+put}for def/PaintType 0 def/FontType 1 def/FontMatrix[0.001 0 0 0.001 0 0]def
+/FontBBox{-25 -23 1500 804}readonly def currentdict end dup/Private 20 dict dup
+begin/ND{def}def/NP{put}def/lenIV -1 def/RD{string currentfile exch
+readhexstring pop}def/-|{string currentfile exch readstring pop}executeonly def
+/|-{def}executeonly def/|{put}executeonly def/BlueValues[-20 0 706 736 547 572]
+|-/OtherBlues[-211 -203]|-/BlueScale 0.0312917 def/MinFeature{16 16}|-/StdHW
+[60]|-/StdVW[71]|-/ForceBold false def/password 5839 def/Erode{8.5 dup 3 -1
+roll 0.1 mul exch 0.5 sub mul cvi sub dup mul 71 0 dtransform dup mul exch dup
+mul add le{pop pop 1.0 1.0}{pop pop 0.0 1.5}ifelse}def/OtherSubrs[{}{}{}
+{systemdict/internaldict known not{pop 3}{1183615869 systemdict/internaldict
+get exec dup/startlock known{/startlock get exec}{dup/strtlck known{/strtlck
+get exec}{pop 3}ifelse}ifelse}ifelse}executeonly]|-/Subrs 5 array dup 0
+<8E8B0C100C110C110C210B>put dup 1<8B8C0C100B>put dup 2<8B8D0C100B>put dup 3<0B>
+put dup 4<8E8C8E0C100C110A0B>put |- 2 index/CharStrings 256 dict dup begin
+/.notdef<8b8b0d0e>def end end put put dup/FontName get exch definefont pop}bind
+def/AddEuroGlyph{2 index exch EuroEncodingIdx 1 eq{EuroFontHdr}if systemdict
+begin/Euro findfont dup dup/Encoding get 5 1 roll/Private get begin/CharStrings
+get dup 3 index known{pop pop pop pop end end}{begin 1 index exch def end end
+end EuroEncodingIdx dup 1 add/EuroEncodingIdx exch def exch put}ifelse}bind def
+/GetNewXUID{currentdict/XUID known{[7 XUID aload pop]true}{currentdict/UniqueID
+known{[7 UniqueID]true}{false}ifelse}ifelse}bind def/BuildT3EuroFont{exch 16
+dict begin dup/FontName exch def findfont dup/Encoding get/Encoding exch def
+dup length 1 add dict copy dup/FID undef begin dup dup/FontName exch def
+/Encoding 256 array 0 1 255{1 index exch/.notdef put}for def GetNewXUID{/XUID
+exch def}if currentdict end definefont pop/BaseFont exch findfont 1000
+scalefont def/EuroFont exch findfont 1000 scalefont def pop/EuroGlyphName exch
+def/FontType 3 def/FontMatrix[.001 0 0 .001 0 0]def/FontBBox BaseFont/FontBBox
+get def/Char 1 string def/BuildChar{exch dup begin/Encoding get 1 index get
+/Euro eq{BaseFont T1FontHasEuro{false}{true}ifelse}{false}ifelse{EuroFont
+setfont pop userdict/Idx 0 put EuroFont/Encoding get{EuroGlyphName eq{exit}
+{userdict/Idx Idx 1 add put}ifelse}forall userdict/Idx get}{dup dup Encoding
+exch get BaseFont/Encoding get 3 1 roll put BaseFont setfont}ifelse Char 0 3 -1
+roll put Char stringwidth newpath 0 0 moveto Char true charpath flattenpath
+pathbbox setcachedevice 0 0 moveto Char show end}bind def currentdict end dup
+/FontName get exch definefont pop}bind def/AddEuroToT1Font{dup findfont dup
+length 10 add dict copy dup/FID undef begin/EuroFont 3 -1 roll findfont 1000
+scalefont def CharStrings dup length 1 add dict copy begin/Euro{EuroFont
+setfont pop EuroGBBox aload pop setcachedevice 0 0 moveto EuroGName glyphshow}
+bind def currentdict end/CharStrings exch def GetNewXUID{/XUID exch def}if 3 1
+roll/EuroGBBox exch def/EuroGName exch def currentdict end definefont pop}bind
+def/BuildNewFont{UseT3EuroFont{BuildT3EuroFont}{pop AddEuroToT1Font}ifelse}bind
+def/UseObliqueEuro{findfont/FontMatrix get dup 2 get 0 eq exch dup 0 get exch 3
+get eq and UseT3EuroFont or}bind def
+%%EndResource
+end reinitialize
+/Courier-Bold FontHasEuro not
+{
+/Euro.Courier-Bold
+ [600 0 6 -12 585 612 ] 
+<91F8EC0DDBE803F875E7037FE701F755DC01F7D7DC01F8C47701F80FF7A615FB61068A94
+8B958B95088B928B918C9208F76E06A4DC05FB76068F0ADBE803F875E7037FE701F755DC
+01F7D7DC01F89CE701A1D4C1B6DF8B08BF8BC46DA067084A07E706F773072F068F0ADBE8
+03F875E7037FE701F755DC01F7D7DC01F8C4770157078F0ADBE803F875E7037FE701F755
+DC01F7D7DC01F89CE70165AE549C5E8B08FB138B2F386BFB11084806723A05DB0678078B
+818B818C81085306723A05E806A9FB08DD32F7288B08B28BF7039FD7D00853CF056B754E
+603B8B08448B51B56ED208F73606090E>
+AddEuroGlyph
+/Euro /Courier-Bold /Courier-Bold-Copy BuildNewFont
+} if
 F /F0 0 /256 T /Courier-Bold mF 
 /F0S85 F0 [133 0 0 -133 0 0 ] mFS
 F0S85 Ji 
-1250 1582 M (Eq)[80  0]xS 
-
-%%IncludeResource: font Times-Roman
-F /F1 0 /256 T /Times-Roman mF 
+1267 1594 M (Eq)[80  0]xS 
+
+%%IncludeResource: font TimesNewRomanPSMT
+/TimesNewRomanPSMT FontHasEuro not
+{
+/Euro.TimesNewRomanPSMT
+ [500 0 -10 -12 482 676 ] 
+<80F8880DBAEF03F8629E037FB401F7ADB101F7FCB101F918AB01F83DF7FC1596B105FBB5
+0695EAB0F72BF70D8B08EE8BB34A932F089E06F7260757A6539B518B088F0ABCEA03F862
+9E037FB401F7ADB101F7FCB101F918AB01FB328B36FB1C77FB22086206806505BB068A7D
+8B7E8B7D086706806505BC0696FB1FC5FB2EF7388B08F58BC0C5BFDE087C95055B486460
+328B08FB0C8B68F73288E908F7950696B105FBA1068CB405090E>
+AddEuroGlyph
+/Euro /TimesNewRomanPSMT /TimesNewRomanPSMT-Copy BuildNewFont
+} if
+F /F1 0 /256 T /TimesNewRomanPSMT mF 
 /F1S64 F1 [100 0 0 -100 0 0 ] mFS
 F1S64 Ji 
-955 1718 M (All except IO, \()[72 28 28 25 44 51 44 44 51 28 26 32 72 25 25  0]xS 
-1583 1718 M (-)S 
-1617 1718 M (>\))[56  0]xS 
+972 1730 M (All except IO, \()[72 28 28 25 44 51 44 44 51 28 26 32 72 25 25  0]xS 
+1600 1730 M (-)S 
+1634 1730 M (>\))[56  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -291,7 +392,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1353 2031 m 1088 2031 873 2140 873 2273 c 873 2407 1088 2515 1353 2515 c 1618 2515 1833 2407 1833 2273 c 1833 2140 1618 2031 1353 2031 c CP
+1370 2043 m 1105 2043 890 2152 890 2285 c 890 2419 1105 2527 1370 2527 c 1635 2527 1850 2419 1850 2285 c 1850 2152 1635 2043 1370 2043 c CP
 S
 GSE
 
@@ -299,15 +400,15 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-1232 2194 M (Ord)[80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+1249 2206 M (Ord)[80 80  0]xS 
 F1S64 Ji 
-1055 2329 M (All except \()[72 28 28 25 44 51 44 44 51 28 25  0]xS 
-1528 2329 M (-)S 
-1562 2329 M (>\))[56  0]xS 
-1104 2449 M (IO,  )[32 72 25 25  0]xS 
-1285 2449 M (IOError)[31 73 61 34 33 50  0]xS 
+1072 2341 M (All except \()[72 28 28 25 44 51 44 44 51 28 25  0]xS 
+1545 2341 M (-)S 
+1579 2341 M (>\))[56  0]xS 
+1121 2461 M (IO,  )[32 72 25 25  0]xS 
+1302 2461 M (IOError)[31 73 61 34 33 50  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -316,7 +417,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2439 2033 m 2173 2033 1957 2141 1957 2274 c 1957 2406 2173 2514 2439 2514 c 2706 2514 2922 2406 2922 2274 c 2922 2141 2706 2033 2439 2033 c CP
+2456 2045 m 2190 2045 1974 2153 1974 2286 c 1974 2418 2190 2526 2456 2526 c 2723 2526 2939 2418 2939 2286 c 2939 2153 2723 2045 2456 2045 c CP
 S
 GSE
 
@@ -324,13 +425,13 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2319 2195 M (Num)[80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2336 2207 M (Num)[80 80  0]xS 
 F1S64 Ji 
-2192 2330 M (Int)[32 50  0]xS 
-2302 2330 M (, Integer, )[25 27 32 50 29 45 49 45 33 25  0]xS 
-2163 2450 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+2209 2342 M (Int)[32 50  0]xS 
+2319 2342 M (, Integer, )[25 27 32 50 29 45 49 45 33 25  0]xS 
+2180 2462 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -339,22 +440,22 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1334 1838 m 1351 1990 l 1352 1991 1350 1993 1349 1993 c 1347 1993 1345 1992 1345 1990 c 1328 1839 l 1328 1837 1329 1836 1331 1836 c 1332 1835 1334 1837 1334 1838 c CP
-1372 1979 m 1353 2031 l 1323 1985 l CP
+1351 1850 m 1368 2002 l 1369 2003 1367 2005 1366 2005 c 1364 2005 1362 2004 1362 2002 c 1345 1851 l 1345 1849 1346 1848 1348 1848 c 1349 1847 1351 1849 1351 1850 c CP
+1389 1991 m 1370 2043 l 1340 1997 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1332 1836 m 2399 2023 l 2401 2023 2402 2025 2402 2027 c 2401 2028 2400 2030 2398 2029 c 1331 1842 l 1329 1841 1328 1840 1328 1838 c 1328 1836 1330 1835 1332 1836 c CP
-2395 2000 m 2439 2033 l 2386 2049 l CP
+1349 1848 m 2416 2035 l 2418 2035 2419 2037 2419 2039 c 2418 2040 2417 2042 2415 2041 c 1348 1854 l 1346 1853 1345 1852 1345 1850 c 1345 1848 1347 1847 1349 1848 c CP
+2412 2012 m 2456 2045 l 2403 2061 l CP
 F
 GSE
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2424 1377 m 2191 1377 2002 1478 2002 1602 c 2002 1726 2191 1827 2424 1827 c 2657 1827 2846 1726 2846 1602 c 2846 1478 2657 1377 2424 1377 c CP
+2441 1389 m 2208 1389 2019 1490 2019 1614 c 2019 1738 2208 1839 2441 1839 c 2674 1839 2863 1738 2863 1614 c 2863 1490 2674 1389 2441 1389 c CP
 S
 GSE
 
@@ -362,14 +463,14 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2263 1523 M (Show)[80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2280 1535 M (Show)[80 80 80  0]xS 
 F1S64 Ji 
-2216 1658 M (All except)[72 28 28 25 44 51 44 44 51  0]xS 
-2268 1778 M (IO, \()[32 72 25 26  0]xS 
-2456 1778 M (-)S 
-2489 1778 M (>\))[56  0]xS 
+2233 1670 M (All except)[72 28 28 25 44 51 44 44 51  0]xS 
+2285 1790 M (IO, \()[32 72 25 26  0]xS 
+2473 1790 M (-)S 
+2506 1790 M (>\))[56  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -378,7 +479,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2402 2774 m 2149 2774 1944 2876 1944 3002 c 1944 3127 2149 3229 2402 3229 c 2656 3229 2861 3127 2861 3002 c 2861 2876 2656 2774 2402 2774 c CP
+2419 2786 m 2166 2786 1961 2888 1961 3014 c 1961 3139 2166 3241 2419 3241 c 2673 3241 2878 3139 2878 3014 c 2878 2888 2673 2786 2419 2786 c CP
 S
 GSE
 
@@ -386,13 +487,13 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2242 2923 M (Real)[80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2259 2935 M (Real)[80 80 80  0]xS 
 F1S64 Ji 
-2154 3058 M (Int)[32 50  0]xS 
-2264 3058 M (, Integer, )[25 27 32 50 29 45 49 45 33 25  0]xS 
-2127 3178 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+2171 3070 M (Int)[32 50  0]xS 
+2281 3070 M (, Integer, )[25 27 32 50 29 45 49 45 33 25  0]xS 
+2144 3190 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -401,7 +502,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3408 2779 m 3139 2779 2921 2879 2921 3002 c 2921 3125 3139 3224 3408 3224 c 3677 3224 3895 3125 3895 3002 c 3895 2879 3677 2779 3408 2779 c CP
+3425 2791 m 3156 2791 2938 2891 2938 3014 c 2938 3137 3156 3236 3425 3236 c 3694 3236 3912 3137 3912 3014 c 3912 2891 3694 2791 3425 2791 c CP
 S
 GSE
 
@@ -409,11 +510,11 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-3007 2982 M (Fractional)[80 80 80 80 80 80 81 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+3024 2994 M (Fractional)[80 80 80 80 80 80 81 80 80  0]xS 
 F1S64 Ji 
-3132 3118 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+3149 3130 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -422,7 +523,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1341 2696 m 1043 2696 802 2833 802 3001 c 802 3170 1043 3306 1341 3306 c 1638 3306 1879 3170 1879 3001 c 1879 2833 1638 2696 1341 2696 c CP
+1358 2708 m 1060 2708 819 2845 819 3013 c 819 3182 1060 3318 1358 3318 c 1655 3318 1896 3182 1896 3013 c 1896 2845 1655 2708 1358 2708 c CP
 S
 GSE
 
@@ -430,16 +531,16 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-1180 2862 M (Enum)[80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+1197 2874 M (Enum)[80 80 80  0]xS 
 F1S64 Ji 
-845 2998 M (\(\), )[33 33 25  0]xS 
-961 2998 M (Bool)[66 50 50  0]xS 
-1155 2998 M (, Char, Ordering,)[25 25 67 51 44 33 25 25 72 33 51 45 33 28 51 49  0]xS 
-977 3118 M (Int)[32 50  0]xS 
-1087 3118 M (, Integer, Float,)[25 27 32 50 29 45 49 45 33 25 25 55 28 51 44 28  0]xS 
-1193 3238 M (Double)[72 50 50 50 28  0]xS 
+862 3010 M (\(\), )[33 33 25  0]xS 
+978 3010 M (Bool)[66 50 50  0]xS 
+1172 3010 M (, Char, Ordering,)[25 25 67 51 44 33 25 25 72 33 51 45 33 28 51 49  0]xS 
+994 3130 M (Int)[32 50  0]xS 
+1104 3130 M (, Integer, Float,)[25 27 32 50 29 45 49 45 33 25 25 55 28 51 44 28  0]xS 
+1210 3250 M (Double)[72 50 50 50 28  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -448,7 +549,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2362 3529 m 2141 3529 1962 3628 1962 3750 c 1962 3871 2141 3970 2362 3970 c 2583 3970 2761 3871 2761 3750 c 2761 3628 2583 3529 2362 3529 c CP
+2379 3541 m 2158 3541 1979 3640 1979 3762 c 1979 3883 2158 3982 2379 3982 c 2600 3982 2778 3883 2778 3762 c 2778 3640 2600 3541 2379 3541 c CP
 S
 GSE
 
@@ -456,11 +557,11 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2042 3730 M (RealFrac)[80 80 80 80 80 80 81  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2059 3742 M (RealFrac)[80 80 80 80 80 80 81  0]xS 
 F1S64 Ji 
-2086 3866 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+2103 3878 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -469,7 +570,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3284 3529 m 3040 3529 2842 3628 2842 3750 c 2842 3871 3040 3970 3284 3970 c 3528 3970 3726 3871 3726 3750 c 3726 3628 3528 3529 3284 3529 c CP
+3301 3541 m 3057 3541 2859 3640 2859 3762 c 2859 3883 3057 3982 3301 3982 c 3545 3982 3743 3883 3743 3762 c 3743 3640 3545 3541 3301 3541 c CP
 S
 GSE
 
@@ -477,11 +578,11 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2963 3730 M (Floating)[80 80 80 80 80 80 81  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2980 3742 M (Floating)[80 80 80 80 80 80 81  0]xS 
 F1S64 Ji 
-3008 3866 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+3025 3878 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -490,7 +591,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1444 3529 m 1227 3529 1051 3628 1051 3750 c 1051 3871 1227 3970 1444 3970 c 1661 3970 1837 3871 1837 3750 c 1837 3628 1661 3529 1444 3529 c CP
+1461 3541 m 1244 3541 1068 3640 1068 3762 c 1068 3883 1244 3982 1461 3982 c 1678 3982 1854 3883 1854 3762 c 1854 3640 1678 3541 1461 3541 c CP
 S
 GSE
 
@@ -498,12 +599,12 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-1124 3730 M (Integral)[80 80 80 80 80 80 81  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+1141 3742 M (Integral)[80 80 80 80 80 80 81  0]xS 
 F1S64 Ji 
-1221 3866 M (Int)[32 50  0]xS 
-1331 3866 M (, Integer)[25 27 32 50 29 45 49 45  0]xS 
+1238 3878 M (Int)[32 50  0]xS 
+1348 3878 M (, Integer)[25 27 32 50 29 45 49 45  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -512,7 +613,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2701 4169 m 2446 4169 2239 4258 2239 4369 c 2239 4479 2446 4569 2701 4569 c 2956 4569 3162 4479 3162 4369 c 3162 4258 2956 4169 2701 4169 c CP
+2718 4181 m 2463 4181 2256 4270 2256 4381 c 2256 4491 2463 4581 2718 4581 c 2973 4581 3179 4491 3179 4381 c 3179 4270 2973 4181 2718 4181 c CP
 S
 GSE
 
@@ -520,11 +621,11 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2341 4350 M (RealFloat)[80 80 80 80 80 80 81 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2358 4362 M (RealFloat)[80 80 80 80 80 80 81 80  0]xS 
 F1S64 Ji 
-2425 4486 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
+2442 4498 M (Float, Double)[55 28 50 44 28 25 25 72 50 50 50 29  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -533,86 +634,86 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2427 1827 m 2439 1992 l 2440 1993 2438 1995 2437 1995 c 2435 1995 2433 1994 2433 1992 c 2421 1827 l 2421 1826 2422 1824 2424 1824 c 2425 1824 2427 1825 2427 1827 c CP
-2461 1982 m 2439 2033 l 2411 1986 l CP
+2444 1839 m 2456 2004 l 2457 2005 2455 2007 2454 2007 c 2452 2007 2450 2006 2450 2004 c 2438 1839 l 2438 1838 2439 1836 2441 1836 c 2442 1836 2444 1837 2444 1839 c CP
+2478 1994 m 2456 2045 l 2428 1998 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1354 2512 m 2363 2761 l 2365 2761 2366 2763 2366 2765 c 2365 2767 2363 2768 2362 2767 c 1352 2518 l 1351 2517 1350 2516 1350 2514 c 1350 2512 1352 2511 1354 2512 c CP
-2360 2738 m 2403 2774 l 2348 2786 l CP
+1371 2524 m 2380 2773 l 2382 2773 2383 2775 2383 2777 c 2382 2779 2380 2780 2379 2779 c 1369 2530 l 1368 2529 1367 2528 1367 2526 c 1367 2524 1369 2523 1371 2524 c CP
+2377 2750 m 2420 2786 l 2365 2798 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2443 2514 m 2412 2733 l 2412 2735 2410 2736 2408 2736 c 2407 2736 2405 2734 2406 2732 c 2436 2513 l 2437 2512 2438 2510 2440 2511 c 2442 2511 2443 2512 2443 2514 c CP
-2435 2728 m 2403 2774 l 2385 2721 l CP
+2460 2526 m 2429 2745 l 2429 2747 2427 2748 2425 2748 c 2424 2748 2422 2746 2423 2744 c 2453 2525 l 2454 2524 2455 2522 2457 2523 c 2459 2523 2460 2524 2460 2526 c CP
+2452 2740 m 2420 2786 l 2402 2733 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2404 3232 m 1485 3520 l 1484 3520 1482 3519 1481 3518 c 1481 3516 1482 3514 1484 3514 c 2402 3226 l 2404 3226 2405 3227 2406 3228 c 2407 3230 2406 3232 2404 3232 c CP
-1500 3538 m 1445 3529 l 1485 3491 l CP
+2421 3244 m 1502 3532 l 1501 3532 1499 3531 1498 3530 c 1498 3528 1499 3526 1501 3526 c 2419 3238 l 2421 3238 2422 3239 2423 3240 c 2424 3242 2423 3244 2421 3244 c CP
+1517 3550 m 1462 3541 l 1502 3503 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2406 3230 m 2371 3488 l 2371 3490 2369 3491 2368 3491 c 2366 3491 2365 3489 2365 3488 c 2400 3229 l 2400 3227 2402 3226 2403 3226 c 2405 3226 2406 3228 2406 3230 c CP
-2394 3483 m 2362 3529 l 2344 3476 l CP
+2423 3242 m 2388 3500 l 2388 3502 2386 3503 2385 3503 c 2383 3503 2382 3501 2382 3500 c 2417 3241 l 2417 3239 2419 3238 2420 3238 c 2422 3238 2423 3240 2423 3242 c CP
+2411 3495 m 2379 3541 l 2361 3488 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3411 3225 m 3303 3492 l 3302 3493 3300 3494 3299 3494 c 3297 3493 3296 3491 3297 3490 c 3405 3223 l 3406 3221 3408 3221 3409 3221 c 3411 3222 3412 3224 3411 3225 c CP
-3326 3492 m 3284 3529 l 3280 3474 l CP
+3428 3237 m 3320 3504 l 3319 3505 3317 3506 3316 3506 c 3314 3505 3313 3503 3314 3502 c 3422 3235 l 3423 3233 3425 3233 3426 3233 c 3428 3234 3429 3236 3428 3237 c CP
+3343 3504 m 3301 3541 l 3297 3486 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3409 3227 m 2403 3521 l 2402 3521 2400 3520 2399 3519 c 2399 3517 2400 3515 2402 3515 c 3407 3221 l 3409 3221 3411 3222 3411 3223 c 3412 3225 3411 3227 3409 3227 c CP
-2417 3539 m 2362 3529 l 2403 3491 l CP
+3426 3239 m 2420 3533 l 2419 3533 2417 3532 2416 3531 c 2416 3529 2417 3527 2419 3527 c 3424 3233 l 3426 3233 3428 3234 3428 3235 c 3429 3237 3428 3239 3426 3239 c CP
+2434 3551 m 2379 3541 l 2420 3503 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3284 3973 m 2741 4158 l 2740 4159 2738 4158 2737 4156 c 2737 4155 2738 4153 2739 4152 c 3282 3967 l 3284 3966 3286 3967 3286 3969 c 3287 3971 3286 3972 3284 3973 c CP
-2756 4176 m 2701 4169 l 2740 4129 l CP
+3301 3985 m 2758 4170 l 2757 4171 2755 4170 2754 4168 c 2754 4167 2755 4165 2756 4164 c 3299 3979 l 3301 3978 3303 3979 3303 3981 c 3304 3983 3303 3984 3301 3985 c CP
+2773 4188 m 2718 4181 l 2757 4141 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2364 3967 m 2667 4145 l 2668 4146 2669 4148 2668 4149 c 2667 4151 2665 4151 2663 4150 c 2361 3973 l 2359 3972 2359 3970 2360 3968 c 2361 3967 2362 3966 2364 3967 c CP
-2670 4122 m 2701 4169 l 2645 4165 l CP
+2381 3979 m 2684 4157 l 2685 4158 2686 4160 2685 4161 c 2684 4163 2682 4163 2680 4162 c 2378 3985 l 2376 3984 2376 3982 2377 3980 c 2378 3979 2379 3978 2381 3979 c CP
+2687 4134 m 2718 4181 l 2662 4177 l CP
 F
 GSE
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1343 3305 m 1430 3490 l 1431 3492 1430 3494 1428 3494 c 1427 3495 1425 3494 1424 3493 c 1338 3308 l 1337 3306 1338 3304 1339 3304 c 1341 3303 1343 3303 1343 3305 c CP
-1446 3473 m 1445 3529 l 1401 3495 l CP
+1360 3317 m 1447 3502 l 1448 3504 1447 3506 1445 3506 c 1444 3507 1442 3506 1441 3505 c 1355 3320 l 1354 3318 1355 3316 1356 3316 c 1358 3315 1360 3315 1360 3317 c CP
+1463 3485 m 1462 3541 l 1418 3507 l CP
 F
 GSE
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-3382 1364 m 3192 1364 3038 1470 3038 1601 c 3038 1732 3192 1839 3382 1839 c 3572 1839 3726 1732 3726 1601 c 3726 1470 3572 1364 3382 1364 c CP
+3399 1376 m 3209 1376 3055 1482 3055 1613 c 3055 1744 3209 1851 3399 1851 c 3589 1851 3743 1744 3743 1613 c 3743 1482 3589 1376 3399 1376 c CP
 S
 GSE
 
@@ -620,40 +721,14 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-3222 1522 M (Read)[80 80 80  0]xS 
-F1S64 Ji 
-3175 1657 M (All except)[72 28 28 25 44 51 44 44 51  0]xS 
-3226 1777 M (IO, \()[32 72 25 26  0]xS 
-3414 1777 M (-)S 
-3447 1777 M (>\))[56  0]xS 
-Pscript_WinNT_Compat begin /$x mysetup def end
-Pscript_WinNT_Incr dup /suspend get exec
-Pscript_WinNT_Compat dup /initialize get exec
-%%BeginDocument: Pscript_Win_PassThrough
-userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
-1 1 10 8.3333 [] 0 1 GpPBeg
-0.0039 0.0039 0.0039 SC
-NP
-3489 1996 m 3248 1996 3052 2120 3052 2274 c 3052 2427 3248 2551 3489 2551 c 3731 2551 3927 2427 3927 2274 c 3927 2120 3731 1996 3489 1996 c CP
-S
-GSE
-
-%%EndDocument
-
-Pscript_WinNT_Compat dup /suspend get exec
-Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-3209 2195 M (Bounded)[80 80 80 80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+3239 1534 M (Read)[80 80 80  0]xS 
 F1S64 Ji 
-3131 2330 M (Int)[32 50  0]xS 
-3241 2330 M (, Char, )[25 25 67 51 44 33 25  0]xS 
-3537 2330 M (Bool)[66 50 50  0]xS 
-3731 2330 M (, \(\))[25 25 34  0]xS 
-3165 2450 M (Ordering, )[72 33 50 44 33 28 51 49 25  0]xS 
-3576 2450 M (tuples)[28 50 50 28 44  0]xS 
+3192 1669 M (All except)[72 28 28 25 44 51 44 44 51  0]xS 
+3243 1789 M (IO, \()[32 72 25 26  0]xS 
+3431 1789 M (-)S 
+3464 1789 M (>\))[56  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -662,7 +737,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1394 4146 m 1150 4146 952 4244 952 4366 c 952 4487 1150 4586 1394 4586 c 1638 4586 1836 4487 1836 4366 c 1836 4244 1638 4146 1394 4146 c CP
+3506 2008 m 3265 2008 3069 2132 3069 2286 c 3069 2439 3265 2563 3506 2563 c 3748 2563 3944 2439 3944 2286 c 3944 2132 3748 2008 3506 2008 c CP
 S
 GSE
 
@@ -670,11 +745,16 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-1194 4347 M (Monad)[80 80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+3226 2207 M (Bounded)[80 80 80 80 80 80  0]xS 
 F1S64 Ji 
-1120 4482 M (IO, [], Maybe)[32 72 25 25 34 34 25 25 89 45 48 51  0]xS 
+3148 2342 M (Int)[32 50  0]xS 
+3258 2342 M (, Char, )[25 25 67 51 44 33 25  0]xS 
+3554 2342 M (Bool)[66 50 50  0]xS 
+3748 2342 M (, \(\))[25 25 34  0]xS 
+3182 2462 M (Ordering, )[72 33 50 44 33 28 51 49 25  0]xS 
+3593 2462 M (tuples)[28 50 50 28 44  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -683,7 +763,7 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1394 4945 m 1150 4945 952 5044 952 5165 c 952 5287 1150 5386 1394 5386 c 1638 5386 1836 5287 1836 5165 c 1836 5044 1638 4945 1394 4945 c CP
+1640 4967 m 1396 4967 1198 5066 1198 5187 c 1198 5309 1396 5407 1640 5407 c 1885 5407 2083 5309 2083 5187 c 2083 5066 1885 4967 1640 4967 c CP
 S
 GSE
 
@@ -691,27 +771,20 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-1033 5146 M (MonadPlus)[80 80 80 80 80 80 81 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+1440 5168 M (Monad)[80 80 80 80  0]xS 
 F1S64 Ji 
-1120 5281 M (IO, [], Maybe)[32 72 25 25 34 34 25 25 89 45 48 51  0]xS 
+1366 5304 M (IO, [], Maybe)[32 72 25 25 34 34 25 25 89 45 48 51  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
 %%BeginDocument: Pscript_Win_PassThrough
 userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto} bind def /m {moveto} bind def /NP {newpath} bind def /CP {closepath} bind def /SC {setrgbcolor} bind def /S {stroke} bind def /F {fill} bind def /AF {eofill} bind def 1 eq {setdash setlinewidth setmiterlimit setlinejoin setlinecap} if} put /GSE {end grestore} def
-0 GpPBeg
-0.0039 0.0039 0.0039 SC
-NP
-1397 4586 m 1397 4903 l 1397 4905 1395 4906 1394 4906 c 1392 4906 1391 4905 1391 4903 c 1391 4586 l 1391 4584 1392 4582 1394 4582 c 1395 4582 1397 4584 1397 4586 c CP
-1419 4895 m 1394 4945 l 1369 4895 l CP
-F
-GSE
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2610 4946 m 2366 4946 2168 5044 2168 5165 c 2168 5286 2366 5385 2610 5385 c 2854 5385 3052 5286 3052 5165 c 3052 5044 2854 4946 2610 4946 c CP
+3057 4967 m 2813 4967 2615 5066 2615 5187 c 2615 5308 2813 5406 3057 5406 c 3301 5406 3499 5308 3499 5187 c 3499 5066 3301 4967 3057 4967 c CP
 S
 GSE
 
@@ -719,11 +792,11 @@ GSE
 
 Pscript_WinNT_Compat dup /suspend get exec
 Pscript_WinNT_Incr dup /resume get exec
-/DeviceGray dup setcolorspace /colspABC exch def
-0 0 scol F0S85 Ji 
-2329 5146 M (Functor)[80 80 80 80 80 80  0]xS 
+/DeviceRGB dup setcolorspace /colspABC exch def
+0 0 0 1 scol F0S85 Ji 
+2776 5167 M (Functor)[80 80 80 80 80 80  0]xS 
 F1S64 Ji 
-2335 5281 M (IO, [], Maybe)[32 72 25 25 34 34 25 25 89 45 48 51  0]xS 
+2783 5303 M (IO, [], Maybe)[32 72 25 25 34 34 25 25 89 45 48 51  0]xS 
 Pscript_WinNT_Compat begin /$x mysetup def end
 Pscript_WinNT_Incr dup /suspend get exec
 Pscript_WinNT_Compat dup /initialize get exec
@@ -732,14 +805,14 @@ userdict /GpPBeg {gsave initclip 13 dict begin /c {curveto} bind def /l {lineto}
 0 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-2440 2511 m 3369 2765 l 3371 2766 3372 2767 3371 2769 c 3371 2771 3369 2772 3367 2771 c 2439 2517 l 2437 2516 2436 2515 2436 2513 c 2437 2511 2439 2510 2440 2511 c CP
-3367 2742 m 3408 2779 l 3353 2790 l CP
+2457 2523 m 3386 2777 l 3388 2778 3389 2779 3388 2781 c 3388 2783 3386 2784 3384 2783 c 2456 2529 l 2454 2528 2453 2527 2453 2525 c 2454 2523 2456 2522 2457 2523 c CP
+3384 2754 m 3425 2791 l 3370 2802 l CP
 F
 GSE
 1 1 10 8.3333 [] 0 1 GpPBeg
 0.0039 0.0039 0.0039 SC
 NP
-1260 1246 m 952 1246 702 1496 702 1804 c 702 5038 l 702 5346 952 5596 1260 5596 c 3494 5596 l 3802 5596 4052 5346 4052 5038 c 4052 1804 l 4052 1496 3802 1246 3494 1246 c CP
+1277 1258 m 969 1258 719 1508 719 1816 c 719 5050 l 719 5358 969 5608 1277 5608 c 3511 5608 l 3819 5608 4069 5358 4069 5050 c 4069 1816 l 4069 1508 3819 1258 3511 1258 c CP
 S
 GSE
 
@@ -753,7 +826,7 @@ LH
 %%Trailer
 %%DocumentNeededResources: 
 %%+ font Courier-Bold
-%%+ font Times-Roman
+%%+ font TimesNewRomanPSMT
 %%DocumentSuppliedResources: 
 %%+ procset Pscript_WinNT_ErrorHandler 5.0 0
 %%+ procset Pscript_FatalError 5.0 0
@@ -762,5 +835,7 @@ LH
 %%+ procset Pscript_WinNT_Compat 5.0 0
 %%+ procset Pscript_Text 5.0 0
 %%+ procset Pscript_Encoding256 5.0 0
+%%+ procset Pscript_Win_Euro_L2 5.0 0
 Pscript_WinNT_Incr dup /terminate get exec
 %%EOF
+
index b3f3747..5941925 100644 (file)
Binary files a/report/classes.ppt and b/report/classes.ppt differ
index 955ff6c..a6919c6 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/decls.verb,v 1.14 2001/12/21 16:00:24 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/decls.verb,v 1.15 2002/12/02 11:22:01 simonpj Exp $
 %
 %**<title>The Haskell 98 Report: Declarations</title>
 %*section 4
@@ -26,7 +26,7 @@ topdecls -> topdecl_1 @;@ ... @;@ topdecl_n   & (n>=1)
 topdecl        -> @type@ simpletype @=@ type
        |  @data@ [context @=>@] simpletype @=@ constrs [deriving]
         |  @newtype@ [context @=>@] simpletype @=@ newconstr [deriving]
-       |  @class@ [scontext @=>@] simpleclass [@where@ cdecls]
+       |  @class@ [scontext @=>@] tycls tyvar [@where@ cdecls]
        |  @instance@ [scontext @=>@] qtycls inst [@where@ idecls]
        |  @default@ @(@type_1 @,@ ... @,@ type_n@)@ & \qquad (n>=0)
        |  decl
@@ -576,8 +576,8 @@ useful to assign "field labels" to the components of a data object.
 This allows a specific field to be referenced independently of its
 location within the constructor.
 
-A constructor definition in a @data@ declaration using the record
-syntax (@C { ... }@) assigns labels to the components of the constructor.
+A constructor definition in a @data@ declaration may assign labels to the
+fields of the constructor, using the record syntax (@C { ... }@).
 Constructors using field labels may be freely mixed with constructors
 without them. 
 A constructor with associated field labels may still be used as an
@@ -631,7 +631,7 @@ every occurrence of "K" in an expression by
 \[
 "@(\ @x_1 ... x_n @->@ ( ((K op_1 x_1) op_2 x_2) ... ) op_n x_n)"
 \]
-where "op_i" is the lazy apply function @$@ if "s_i" is of the form "t_i",
+where "op_i" is the non-strict apply function @$@ if "s_i" is of the form "t_i",
 and "op_i" is the strict apply function @$!@ (see
 Section~\ref{strict-eval}) if "s_i" is of the form "@!@ t_i".  Pattern
 matching on "K" is not affected by strictness flags.
@@ -793,7 +793,7 @@ brings into scope both a constructor and a de-constructor:
 \label{class-decls}
 
 @@@
-topdecl        -> @class@ [scontext @=>@] simpleclass [@where@ cdecls]
+topdecl        -> @class@ [scontext @=>@] tycls tyvar [@where@ cdecls]
 scontext -> simpleclass
         |  @(@ simpleclass_1 @,@ ... @,@ simpleclass_n @)@             & (n>=0)
 simpleclass -> qtycls tyvar                    
@@ -969,16 +969,15 @@ binding for a class method that is not in scope, but the name under
 which it is in scope is immaterial; in particular, it may be a qualified
 name.  (This rule is identical to that used for subordinate names in
 export lists --- Section~\ref{export}.)
-For example, this is legal, even though @return@ is in scope only
-with the qualified name @Monad.return@.
+For example, this is legal, even though @range@ is in scope only
+with the qualified name @Ix.range@.
 \bprog
 @
   module A where
-    import qualified Monad
+    import qualified Ix
 
-    instance Monad.Monad T where
-      return = ...
-      (>>=)  = ...
+    instance Ix.Ix T where
+      range = ...
 @
 \eprog
 The declarations may not contain any type
index 8980db6..2e1a112 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/derived.verb,v 1.8 2002/01/29 09:46:41 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/derived.verb,v 1.9 2002/12/02 11:22:01 simonpj Exp $
 %
 % The paragraph describing the formats of standard representations might
 % be deleted, since the info is already in the Prelude.  
@@ -13,6 +13,8 @@
 
 \section{Specification of Derived Instances}
 \label{derived-appendix}
+\index{derived instance}
+
 A {\em derived instance} is an instance declaration that is generated
 automatically in conjunction with a @data@ or @newtype@ declaration.
 The body of a derived instance declaration is derived syntactically from
@@ -80,12 +82,11 @@ omitted or the form @deriving ()@ may be used.
 
 Each derived instance declaration will have the form:
 \[
-"@instance (@cx@,@ C'_1 u'_1@,@ ...@,@ C'_j u'_j @) =>@ C_i (T u_1 ... u_k) @where@ @{@ d @}@"
+"@instance (@cx@, @cx'@) =>@ C_i (T u_1 ... u_k) @where@ @{@ d @}@"
 \]
 where "d" is derived automatically depending on "C_i" and the data
 type declaration for "T" (as will be described in the remainder of
-this section), and "u'_1" through "u'_j" form a subset of "u_1"
-through "u_k".
+this section).
 %% Yale nuked this:
 %% The class assertions "C' u'" are constraints on "T"'s
 %% type variables that are inferred from the instance declarations of the
@@ -116,8 +117,10 @@ through "u_k".
 %% instance (Ord a) => Eq (T1 a) where (C1 x) == (C1 y)  =  x == y
 %% @@
 %% \eprog
-When inferring the context for the derived instances, type synonyms
-in the constructors' argument types must be expanded out first.\index{type synonym}
+
+The context "cx'" is the smallest context satisfying point (2) above.
+For mutually recusive data types, the compiler may need to perform a
+fixpoint calculation to compute it.
 
 The remaining details of the derived
 instances for each of the derivable Prelude classes are now given.
@@ -152,10 +155,13 @@ Derived comparisons always traverse constructors from left to right.
 These examples illustrate this property:
 \bprog
 @
-(1,undefined) == (2,undefined) @"\Rightarrow"@    False
-(undefined,1) == (undefined,2) @"\Rightarrow"@    @"\bot"@
+  (1,undefined) == (2,undefined) @"\Rightarrow"@    False
+  (undefined,1) == (undefined,2) @"\Rightarrow"@    @"\bot"@
 @
 \eprog
+All derived operations of class @Eq@ and @Ord@ are strict in both arguments.
+For example, "@False <=@ \bot" is "\bot", even though @False@ is the first constructor
+of the @Bool@ type.
 
 \subsection{Derived instances of @Enum@}
 \indexdi{Enum}
@@ -176,27 +182,29 @@ is not the index of one of the constructors.
 The definitions of the remaining methods are 
 \bprog
 @
-  enumFrom x           = enumFrom x maxBound
+  enumFrom x           = enumFromTo x lastCon
   enumFromThen x y     = enumFromThenTo x y bound
-                      where
-                        bound | fromEnum y >= fromEnum x = maxBound
-                              | otherwise                = minBound
+                       where
+                         bound | fromEnum y >= fromEnum x = lastCon
+                               | otherwise                = firstCon
   enumFromTo x y       = map toEnum [fromEnum x .. fromEnum y]
   enumFromThenTo x y z = map toEnum [fromEnum x, fromEnum y .. fromEnum z]
 @
 \eprog
+where @firstCon@ and @lastCon@ are respectively the first and last
+constructors listed in the @data@ declaration.
 For example,
 given the datatype:
 \bprog
 @
-data  Color = Red | Orange | Yellow | Green  deriving (Enum)
+  data  Color = Red | Orange | Yellow | Green  deriving (Enum)
 @
 \eprog
 we would have:
 \bprog
 @
-[Orange ..]         ==  [Orange, Yellow, Green]
-fromEnum Yellow     ==  2
+  [Orange ..]         ==  [Orange, Yellow, Green]
+  fromEnum Yellow     ==  2
 @
 \eprog
 
@@ -213,15 +221,15 @@ constructor, the constructor is applied to the bounds for the
 constituent types.  For example, the following datatype:
 \bprog
 @
-data  Pair a b = Pair a b deriving Bounded
+  data  Pair a b = Pair a b deriving Bounded
 @
 \eprog
 would generate the following @Bounded@ instance:
 \bprog
 @
-instance (Bounded a,Bounded b) => Bounded (Pair a b) where
-  minBound = Pair minBound minBound
-  maxBound = Pair maxBound maxBound
+  instance (Bounded a,Bounded b) => Bounded (Pair a b) where
+    minBound = Pair minBound minBound
+    maxBound = Pair maxBound maxBound
 @
 \eprog
 
@@ -237,17 +245,18 @@ They are used to coerce values into strings and parse strings into
 values.
 
 The function @showsPrec d x r@ accepts a precedence level @d@
-(a number from @0@ to @10@), a value @x@, and a string @r@.
+(a number from @0@ to @11@), a value @x@, and a string @r@.
 It returns a string representing @x@ concatenated to @r@.
 @showsPrec@ satisfies the law:
 \[
 "@showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)@"
 \]
 The representation will be enclosed in parentheses if the precedence
-of the top-level constructor operator in @x@ is less than @d@.  Thus,
+of the top-level constructor in @x@ is less than @d@.  Thus,
 if @d@ is @0@ then the result is never surrounded in parentheses; if
-@d@ is @10@ it is always surrounded in parentheses, unless it is an
-atomic expression.  The extra parameter @r@ is essential if tree-like
+@d@ is @11@ it is always surrounded in parentheses, unless it is an
+atomic expression (recall that function application has precedence @10@).
+The extra parameter @r@ is essential if tree-like
 structures are to be printed in linear time rather than time quadratic
 in the size of the tree.
 
@@ -255,12 +264,13 @@ The function @readsPrec d s@ accepts a precedence level @d@ (a number
 from @0@ to @10@) and a string @s@, and attempts to parse a value 
 from the front of the string, returning a list of (parsed value, remaining string) pairs.
 If there is no successful parse, the returned list is empty.
+Parsing of an un-parenthesised infix operator application succeeds only 
+if the precedence of the operator is greater than or equal to @d@.
+
 It should be the case that
-\bprog
-@
-  head (readsPrec d (showsPrec d x "")) == (x,"")
-@
-\eprog
+\begin{center}
+@(x,"")@  is an element of  @(readsPrec d (showsPrec d x ""))@
+\end{center}
 That is, @readsPrec@ should be able to parse the string produced
 by @showsPrec@, and should deliver the value that @showsPrec@ started
 with.
@@ -302,41 +312,83 @@ using non-standard denotations.  This is especially useful for strings
 %shows a positive exponent without a sign.
 
 @readsPrec@ will parse any valid representation of the standard types 
-apart from lists, for
-which only the bracketed form @[@\ldots@]@ is accepted. See
+apart from strings, for which only quoted strings are accepted, and other lists,
+for which only the bracketed form @[@\ldots@]@ is accepted. See
 Appendix~\ref{stdprelude} for full details.
 
-A precise definition of the derived @Read@ and @Show@ instances for
-general types is beyond the scope of this report.  However, the
-derived @Read@ and @Show@ instances have the following properties:
+The result of @show@ is a syntactically correct \Haskell{} expression
+containing only constants, given the fixity declarations in force at
+the point where the type is declared.  It contains only the
+constructor names defined in the data type, parentheses, and
+spaces. When labelled constructor fields are used, braces, commas,
+field names, and equal signs are also used.  Parentheses
+are only added where needed, {\em ignoring associativity}.  No line breaks
+are added. The result of @show@ is readable by @read@ if all component
+types are readable.  (This is true for all instances defined in the
+Prelude but may not be true for user-defined instances.)
+
+Derived instances of @Read@ make the following assumptions, 
+which derived instances of @Show@ obey:
 \begin{itemize}
-\item The result of @show@ is a syntactically correct \Haskell{}
-      expression containing only constants
-      given the fixity declarations in force at the point where
-      the type is declared.
-\item The result of @show@ is readable by @read@ if all component
-      types are readable.  (This is true for all instances defined in
-      the Prelude but may not be true for user-defined instances.)
-\item The instance generated by @Read@ allows arbitrary whitespace
-      between tokens on the input string.  Extra parentheses are also 
-      allowed.
-\item The result of @show@ contains only the constructor names defined
-      in the data type, parentheses, and spaces.  When labelled
-      constructor fields are used, braces, commas, field names, and
-      equal signs are also used.
-      Spaces and parentheses are only added where
-      needed.  No line breaks are added.
-\item If a constructor is defined using labelled field syntax then the derived
-      @show@ for that constructor will use this same
-      syntax; the fields will be in the order declared in the
-      @data@ declaration.  The derived @Read@ instance will use
-      this same syntax: all fields must be present and the declared order
-      must be maintained.
-\item If a constructor is defined in the infix style, the derived @Show@
-      instance will also use infix style.  The derived @Read@ instance will
-      require that the constructor be infix.
+\item If the constructor is defined to be an infix operator, then 
+the derived @Read@ instance will parse only infix applications of the 
+constructor (not the prefix form).
+
+\item Associativity is not used to reduce the occurrence of 
+parentheses, although precedence may be. For example, given
+\bprog
+@
+  infixr 4 :$
+  data T = Int :$ T  |  NT
+@
+\eprog
+then:
+\begin{itemize}
+\item @show (1 :$ 2 :$ NT)@ produces the string @"1 :$ (2 :$ NT)"@.
+\item @read "1 :$ (2 :$ NT)"@ succeeds, with the obvious result.
+\item @read "1 :$ 2 :$ NT"@ fails.
 \end{itemize}
 
+\item 
+If the constructor is defined using record syntax, the derived @Read@ 
+will parse only the record-syntax form, and furthermore, the fields must be 
+given in the same order as the original declaration.
+
+\item The derived @Read@ instance allows arbitrary Haskell whitespace between 
+tokens of the input string.  Extra parentheses are also allowed.
+\end{itemize}
+
+
+% However, the
+% derived @Read@ and @Show@ instances have the following properties:
+% \begin{itemize}
+% \item The result of @show@ is a syntactically correct \Haskell{}
+%       expression containing only constants
+%       given the fixity declarations in force at the point where
+%       the type is declared.
+% \item The result of @show@ is readable by @read@ if all component
+%       types are readable.  (This is true for all instances defined in
+%       the Prelude but may not be true for user-defined instances.)
+% \item The instance generated by @Read@ allows arbitrary whitespace
+%       between tokens on the input string.  Extra parentheses are also 
+%       allowed.
+% \item The result of @show@ contains only the constructor names defined
+%       in the data type, parentheses, and spaces.  When labelled
+%       constructor fields are used, braces, commas, field names, and
+%       equal signs are also used.
+%       Spaces and parentheses are only added where
+%       needed.  No line breaks are added.
+% \item If a constructor is defined using labelled field syntax then the derived
+%       @show@ for that constructor will use this same
+%       syntax; the fields will be in the order declared in the
+%       @data@ declaration.  The derived @Read@ instance will use
+%       this same syntax: all fields must be present and the declared order
+%       must be maintained.
+% \item If a constructor is defined in the infix style, the derived @Show@
+%       instance will also use infix style.  The derived @Read@ instance will
+%       require that the constructor be infix.
+% \end{itemize}
+
 The derived @Read@ and @Show@ instances may be unsuitable for some
 uses.  Some problems include:
 \begin{itemize}
@@ -403,8 +455,8 @@ As a complete example, consider a tree datatype:\nopagebreak
 %Since there is no @deriving@ clause, this is shorthand for:\nopagebreak
 \bprog
 @
-data Tree a = Leaf a | Tree a :^: Tree a
-     deriving (Eq, Ord, Read, Show)
+  data Tree a = Leaf a | Tree a :^: Tree a
+       deriving (Eq, Ord, Read, Show)
 @
 \eprog
 Automatic derivation of
@@ -423,7 +475,7 @@ the class declaration shown in Figure~\ref{standard-classes}
 \begin{figure}[tb]
 \outlinec{
 @
-infix 5 :^:
+infixr 5 :^:
 data Tree a =  Leaf a  |  Tree a :^: Tree a
 
 instance (Eq a) => Eq (Tree a) where
@@ -439,28 +491,33 @@ instance (Ord a) => Ord (Tree a) where
 
 instance (Show a) => Show (Tree a) where
 
-        showsPrec d (Leaf m) = showParen (d >= 10) showStr
+        showsPrec d (Leaf m) = showParen (d > app_prec) showStr
           where
-             showStr = showString "Leaf " . showsPrec 10 m
+             showStr = showString "Leaf " . showsPrec (app_prec+1) m
 
-        showsPrec d (u :^: v) = showParen (d > 4) showStr
+        showsPrec d (u :^: v) = showParen (d > up_prec) showStr
           where
-             showStr = showsPrec 5 u . 
-                       showString " :^: " .
-                       showsPrec 5 v
+             showStr = showsPrec (up_prec+1) u . 
+                       showString " :^: "      .
+                       showsPrec (up_prec+1) v
+                -- Note: right-associativity of :^: ignored
 
 instance (Read a) => Read (Tree a) where
 
-        readsPrec d r =  readParen (d > 4)
+        readsPrec d r =  readParen (d > up_prec)
                          (\r -> [(u:^:v,w) |
-                                 (u,s) <- readsPrec 5 r,
+                                 (u,s) <- readsPrec (up_prec+1) r,
                                  (":^:",t) <- lex s,
-                                 (v,w) <- readsPrec 5 t]) r
+                                 (v,w) <- readsPrec (up_prec+1) t]) r
 
-                      ++ readParen (d > 9)
+                      ++ readParen (d > app_prec)
                          (\r -> [(Leaf m,t) |
                                  ("Leaf",s) <- lex r,
-                                 (m,t) <- readsPrec 10 s]) r
+                                 (m,t) <- readsPrec (app_prec+1) s]) r
+
+up_prec  = 5    -- Precedence of :^:
+app_prec = 10   -- Application has precedence one more than
+               -- the most tightly-binding operator
 @
 }
 %**<div align=center> <h4>Figure 8</h4> </div>
index 727c088..7a38bd4 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/exps.verb,v 1.15 2002/01/29 09:46:41 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/exps.verb,v 1.16 2002/12/02 11:22:01 simonpj Exp $
 %
 %*section 3
 %**<title>The Haskell 98 Report: Expressions</title>
@@ -58,7 +58,9 @@ aexp  ->  qvar                                & (\tr{variable})
        |   @[@ exp_1 [@,@ exp_2] @..@ [exp_3] @]@ & (\tr{arithmetic sequence})
        |   @[@ exp @|@ qual_1 @,@ ... @,@ qual_n @]@   & (\tr{list comprehension}, n>=1)
        |   @(@ exp^{i+1} qop^{(a,i)} @)@        & (\tr{left section})
-        |   @(@ qop^{(a,i)} exp^{i+1} @)@        & (\tr{right section})
+       |   @(@ lexp^{i} qop^{(l,i)} @)@        & (\tr{left section})
+        |   @(@ qop^{(a,i)}_{\langle@-@\rangle}  exp^{i+1} @)@        & (\tr{right section})
+        |   @(@ qop^{(r,i)}_{\langle@-@\rangle}  rexp^{i} @)@        & (\tr{right section})
         |   qcon @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled construction}, n>=0)
         |   aexp_{\langle{}qcon\rangle{}} @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled update}, n >= 1)
 
@@ -114,14 +116,6 @@ aexp       ->  qvar                                & (\tr{variable})
 % \label{syntax-precedences}
 % \end{table}
 
-The grammar is ambiguous regarding the extent of lambda abstractions,
-let expressions, and conditionals.  The ambiguity is resolved by the
-meta-rule that each of these constructs extends as far to the right as
-possible.  As a consequence, each of these constructs has two precedences,
-one to its left, which is the precedence used in the grammar; and
-one to its right, which is obtained via the meta-rule.  See the sample
-parses below.
-
 Expressions involving infix operators are disambiguated by the
 operator's fixity (see Section~\ref{fixity}).  Consecutive
 unparenthesized operators with the same precedence must both be either
@@ -132,11 +126,12 @@ z"'' when "i=j" unless "a=b={\rm l}" or "a=b={\rm r}".
 
 Negation\index{negation} is the only prefix operator in
 \Haskell{}; it has the same precedence as the infix @-@ operator
-defined in the Prelude (see Figure~\ref{prelude-fixities}%
-%*ignore
-, page~\pageref{prelude-fixities}%
-%*endignore
-).
+defined in the Prelude (see Section~\ref{fixity}, Figure~\ref{prelude-fixities}).
+
+The grammar is ambiguous regarding the extent of lambda abstractions,
+let expressions, and conditionals.  The ambiguity is resolved by the
+meta-rule that each of these constructs extends as far to the right as
+possible.  
 
 %      I can't make head or tail of this para, so
 %      I'm just deleting it.  SLPJ Dec 98
@@ -158,6 +153,31 @@ This                                   & Parses as                             \\
 @\ x -> a+b :: Int@                 & @\ x -> ((a+b) :: Int@)               \\
 \hline\et\]
 
+{\em A note about parsing.}  Expressions that involve the interaction 
+of fixities with the let/lambda meta-rule
+may be hard to parse.  For example, the expression
+\bprog
+@
+  let x = True in x == x == True
+@
+\eprog
+cannot possibly mean
+\bprog
+@
+  let x = True in (x == x == True)
+@
+\eprog
+because @(==)@ is a non-associative operator; so the expression must parse thus:
+\bprog
+@
+  (let x = True in (x == x)) == True
+@
+\eprog
+However, implementations may well use a post-parsing pass to deal with fixities,
+so they may well incorrectly deliver the former parse.  Programmers are advised
+to avoid constructs whose parsing involves an interaction of (lack of) associativity
+with the let/lambda meta-rule.
+  
 For the sake of clarity, the rest of this section shows the syntax of
 expressions without their precedences.
 
@@ -165,7 +185,7 @@ expressions without their precedences.
 \label{basic-errors}\index{error}
 Errors during expression evaluation, denoted by "\bot"\index{"\bot"},
 are indistinguishable by a Haskell program from non-termination.  Since \Haskell{} is a
-lazy language, all \Haskell{} types include "\bot".  That is, a value
+non-strict language, all \Haskell{} types include "\bot".  That is, a value
 of any type may be bound to a computation that, when demanded, results
 in an error.  When evaluated, errors cause immediate program
 termination and cannot be caught by the user.  The Prelude provides
@@ -398,8 +418,10 @@ The following identities hold:
 \label{sections}
 %
 @@@
-aexp   ->  @(@ exp qop @)@ 
-       |   @(@ qop exp @)@
+aexp   ->  @(@ exp^{i+1} qop^{(a,i)} @)@        & (\tr{left section})
+       |   @(@ lexp^{i} qop^{(l,i)} @)@        & (\tr{left section})
+        |   @(@ qop^{(a,i)}_{\langle@-@\rangle}  exp^{i+1} @)@        & (\tr{right section})
+        |   @(@ qop^{(r,i)}_{\langle@-@\rangle}  rexp^{i} @)@        & (\tr{right section})
 @@@
 \indexsyn{aexp}%
 
@@ -415,6 +437,34 @@ and similarly for  "@(@e~op@)@".
 For example, @(*a+b)@ is syntactically invalid, but @(+a*b)@ and
 @(*(a+b))@ are valid.  Because @(+)@ is left associative, @(a+b+)@ is syntactically correct,
 but @(+a+b)@ is not; the latter may legally be written as @(+(a+b))@.
+As another example, the expression
+\bprog
+@
+  (let x = 10 in x +)
+@
+\eprog
+is invalid because, by the let/lambda meta-rule (Section~\ref{expressions}),
+the expression
+\bprog
+@
+  (let n = 10 in n + x)
+@
+\eprog
+parses as
+\bprog
+@
+  (let n = 10 in (n + x))
+@
+\eprog
+rather than
+\bprog
+@
+  ((let n = 10 in n) + x)
+@
+\eprog
+% This observation makes it easier to implement the let/lambda meta-rule
+% (Section~\ref{expressions}) because once the operator has been seen it is clear that any
+% legal parse must include the operator in the body of the @let@.
 
 Because @-@ is treated specially in the grammar,
 "@(-@ exp@)@" is not a section, but an application of prefix
@@ -424,6 +474,7 @@ function defined in the Prelude such that
 "@(subtract@ exp@)@" is equivalent to the disallowed section.
 The expression "@(+ (-@ exp@))@" can serve the same purpose.
 
+
 % Changed to allow postfix operators.  That is, in (op x), we no
 % longer add a \x -> which would require op to be binary instead
 % of unary.
@@ -610,7 +661,7 @@ are class methods in the class @Enum@ as defined in the Prelude
 The semantics of arithmetic sequences therefore depends entirely
 on the instance declaration for the type "t".  
 See Section~\ref{enum-class} for more details of which @Prelude@
-type are in @Enum@ and their semantics.
+types are in @Enum@ and their semantics.
 
 
 \subsection{List Comprehensions}
@@ -813,15 +864,35 @@ against the individual alternatives.  The alternatives are tried
 sequentially, from top to bottom.  If "e" matches the pattern in the
 alternative, the guards for that alternative are tried sequentially
 from top to bottom, in the environment of the case expression extended
-by the bindings created during the matching of the pattern and by the
-"decls_i" associated with that alternative.  If one of the guards
-evaluates to @True@, the corresponding right-hand side is evaluated.
+first by the bindings created during the matching of the pattern, and then 
+by the "decls_i" in the @where@ clause associated with that alternative.  
+If one of the guards
+evaluates to @True@, the corresponding right-hand side is evaluated in the
+same environment as the guard.
 If all the guards evaluate to @False@, matching continues with the
 next alternative.  If no match succeeds, the result is "\bot".
 Pattern matching is described in Section~\ref{pattern-matching}, with
 the formal semantics of case expressions in
 Section~\ref{case-semantics}.
 
+{\em A note about parsing}. The expression
+\bprog
+@
+  case x of { (a,_) | let b = not a in b :: Bool -> a }
+@
+\eprog
+is tricky to parse correctly.  It has a single unambiguous parse, namely
+\bprog
+@
+  case x of { (a,_) | (let b = not a in b :: Bool) -> a }
+@
+\eprog
+However, the phrase "@Bool -> a@" is syntactically valid as a type, and
+parsers with limited lookahead may incorrectly commit to this choice, and hence
+reject the program.  Programmers are advised, therefore, to avoid guards that
+end with a type signature --- indeed that is why a "gd" contains 
+an "exp^0" not an "exp".
+
 \subsection{Do Expressions}
 \index{do expression}
 \label{do-expressions}
@@ -893,10 +964,8 @@ and are thus monomorphic.
 \index{data declaration@@{\tt data} declaration}
 \index{label}
 \index{field label|see{label}}
-A datatype declaration may optionally include field labels for some or
-all of the components of the type (see Section~\ref{datatype-decls}).
-Readers unfamiliar with datatype declarations in \Haskell{} may wish
-to read Section \ref{datatype-decls} first.
+A datatype declaration may optionally define field labels
+(see Section~\ref{datatype-decls}).
 These field labels can be used to 
 construct, select from, and update fields in a manner
 that is independent of the overall structure of the datatype.
@@ -969,6 +1038,10 @@ mentioned.
 whose declared types are prefixed by @!@) are omitted during
 construction.  Strict fields are discussed in Section~\ref{strictness-flags}.
 \end{itemize}
+The expression @F {}@, where @F@ is a data constructor, is legal 
+{\em whether or not @F@ was declared with record syntax} (provided @F@ has no strict
+fields --- see the third bullet above); 
+it denotes "@F@ \bot_1 ... \bot_n", where "n" is the arity of @F@.
 
 \outline{
 \paragraph*{Translation:} 
@@ -989,6 +1062,7 @@ The auxiliary function "pick^C_i bs d" is defined as follows:
     the default value "d".
 \end{quote}
 }
+
 \subsubsection{Updates Using Field Labels}
 \label{record-update}
 \index{field label!update}
@@ -1179,18 +1253,6 @@ case e of { [x,y,z]  ->  if x==0 then True else False }
 %This translation is also 
 %assumed prior to the semantics given below.
 
-In the pattern matching rules given below we distinguish two kinds of
-patterns: an {\em irrefutable pattern}
-\index{irrefutable pattern}
-is: a variable, a wildcard, "N apat" where "N" is a constructor
-defined by @newtype@ and "apat" is irrefutable (see
-Section~\ref{datatype-renaming}), 
-\index{newtype declaration@@{\tt newtype} declaration} 
-"var"{\tt @@}"apat" where "apat" is irrefutable,
-or of the form "@~@apat" (whether or not "apat" is irrefutable).
-All other patterns are {\em refutable}.
-\index{refutable pattern}
-
 \subsubsection{Informal Semantics of Pattern Matching}
 
 Patterns are matched against values.  Attempting to match a pattern
@@ -1209,21 +1271,21 @@ The free variables in "apat" are bound to the appropriate values if matching
 "apat" against "v" fails or diverges.  (Binding does {\em
 not} imply evaluation.)
 
-Operationally, this means that no matching is done on an
-irrefutable pattern until one of the variables in the pattern is used.
+Operationally, this means that no matching is done on a
+"@~@apat" pattern until one of the variables in "apat" is used.
 At that point the entire pattern is matched against the value, and if
 the match fails or diverges, so does the overall computation.
 
 \item
-Matching the wildcard pattern @_@ agains any value always succeeds,
+Matching the wildcard pattern @_@ against any value always succeeds,
 and no binding is done.
 
 \item
 Matching the pattern "con pat" against a value, where "con" is a
 constructor defined by @newtype@, depends on the value:
 \begin{itemize}
-\item If the value is of the form "con v", the result is result of matching "pat" against "v".
-\item If the value is "\bot", the result is the result of matching "pat" against "\bot".
+\item If the value is of the form "con v", then "pat" is matched against "v".
+\item If the value is "\bot", then "pat" is matched against "\bot".
 \end{itemize}
 That is, constructors associated with
 @newtype@ serve only to change the type of a value.\index{newtype declaration@@{\tt newtype} declaration}
@@ -1233,8 +1295,7 @@ Matching the pattern "con pat_1 \ldots pat_n" against a value, where "con" is a
 constructor defined by @data@, depends on the value:
 \begin{itemize}
 \item If the value is of the form "con v_1 \ldots v_n", 
-the result of the match is the result of matching the
-sub-patterns left-to-right against the components of the data value;
+sub-patterns are matched left-to-right against the components of the data value;
 if all matches succeed, the overall match
 succeeds; the first to fail or diverge causes the overall match to
 fail or diverge, respectively.  
@@ -1245,32 +1306,36 @@ constructor to "con'", the match fails.
 \item If the value is "\bot", the match diverges.
 \end{itemize}
 
+\item 
+Matching against a constructor using labeled fields is the same as
+matching ordinary constructor patterns except that the fields are
+matched in the order they are named in the field list.  All fields
+listed must be declared by the constructor; fields may not be named
+more than once.  Fields not named by the pattern are ignored (matched
+against @_@).
 
-\item Matching a numeric integer literal pattern "k" against a value "v"
+\item Matching a numeric, character, or string literal pattern "k" against a value "v"
 \index{literal pattern}
-succeeds if "v ~@==@ ~(@fromInteger@~k)", where both @==@ and @fromInteger@
-are overloaded based on the type of the pattern.  The match diverges if
+succeeds if "v ~@==@ ~k", where @==@
+is overloaded based on the type of the pattern.  The match diverges if
 this test diverges.
 
-Matching a floating-point literal is similar, except that @fromRational@ is used,
-as in the case of literals in expressions (Section~\ref{vars-and-lits}).
+The interpretation of numeric literals is exactly as described in Section~\ref{vars-and-lits};
+that is, the overloaded function @fromInteger@ or @fromRational@ is 
+applied to an @Integer@ or @Rational@ literal (resp)
+to convert it to the appropriate type.
 
 \item Matching an "n@+@k" pattern (where "n" is a variable and "k" is a 
 positive integer literal) against a value "v" 
 \index{n+k pattern@@"n@+@k" pattern}
-succeeds if "x ~@>=@ ~(@fromInteger@ k)", resulting in the binding 
-of "n" to "x~@-@~(@fromInteger@~k)",
-and fails otherwise.  Again, the functions @>=@, @fromInteger@, and @-@, are all
+succeeds if "x ~@>=@ ~k", resulting in the binding 
+of "n" to "x~@-@~k",
+and fails otherwise.  Again, the functions @>=@ and @-@ are 
 overloaded, depending on the type of the pattern.
 The match diverges if the comparison diverges.
 
-\item
-Matching against a constructor using labeled fields is the same as
-matching ordinary constructor patterns except that the fields are
-matched in the order they are named in the field list.  All fields
-listed must be declared by the constructor; fields may not be named
-more than once.  Fields not named by the pattern are ignored (matched
-against @_@).
+The interpretation of the literal "k" is the same as in numeric literal
+patterns, except that only integer literals are allowed.
 
 \item
 Matching an as-pattern "var"{\tt @@}"apat" against a value "v" is
@@ -1282,22 +1347,42 @@ then so does the overall match.
 
 Aside from the obvious static type constraints (for
 example, it is a static error to match a character against a
-boolean), the following static class constraints hold: an integer
+boolean), the following static class constraints hold: 
+\begin{itemize}
+\item An integer
 literal pattern
 \index{integer literal pattern}
 can only be matched against a value in the class
-@Num@ and a floating literal pattern
+@Num@.
+\item A floating literal pattern
 \index{floating literal pattern}
 can only be matched against a value
 in the class @Fractional@.
-A "n@+@k" pattern
+\item An "n@+@k" pattern
 \index{n+k pattern@@"n@+@k" pattern}
 can only be matched
 against a value in the class @Integral@.
+\end{itemize}
 
 Many people feel that "n@+@k" patterns should not be used.  These
 patterns may be removed or changed in future versions of \Haskell{}. 
 
+It is sometimes helpful to distinguish two kinds of
+patterns.  Matching an {\em irrefutable pattern}
+\index{irrefutable pattern}
+is non-strict: the pattern matches even if the value to be matched is "\bot".
+Matching a {\em refutable} pattern is strict: if the value to be matched
+\index{refutable pattern}
+is "\bot" the match diverges.
+The irrefutable patterns are as follows:
+a variable, a wildcard, "N apat" where "N" is a constructor
+defined by @newtype@ and "apat" is irrefutable (see
+Section~\ref{datatype-renaming}), 
+\index{newtype declaration@@{\tt newtype} declaration} 
+"var"{\tt @@}"apat" where "apat" is irrefutable,
+or of the form "@~@apat" (whether or not "apat" is irrefutable).
+All other patterns are {\em refutable}.
+
 Here are some examples:
 \begin{enumerate}
 \item If the pattern @['a','b']@ is matched against "@['x',@\bot@]@", then @'a'@
@@ -1331,6 +1416,26 @@ matching:
 (\ ~(x:xs) -> x:x:xs) @"\bot"@   @"\Rightarrow"@   @"\bot"@:@"\bot"@:@"\bot"@
 @
 \eprogNoSkip
+
+\item 
+Consider the following declarations:
+\bprog
+@
+  newtype N = N Bool
+  data    D = D !Bool
+@
+\eprog
+These examples illustrate the difference in pattern matching
+between types defined by @data@ and @newtype@:
+\bprog
+@
+(\  (N True) -> True) @"\bot"@     @"\Rightarrow"@    @"\bot"@
+(\  (D True) -> True) @"\bot"@     @"\Rightarrow"@    @"\bot"@
+(\ ~(D True) -> True) @"\bot"@     @"\Rightarrow"@    True
+@
+\eprog
+Additional examples may be found in Section~\ref{datatype-renaming}.
+
 \end{enumerate}
 \nopagebreak[4]
 % \bprog
@@ -1358,8 +1463,6 @@ matching:
 % @@
 % \eprogNoSkip
 % \end{enumerate}
-Additional examples illustrating some of the subtleties of pattern matching
-may be found in Section~\ref{datatype-renaming}.
 
 Top level patterns in case
 expressions and the set of top level patterns in function or pattern
@@ -1427,10 +1530,9 @@ would generate rather inefficient code.
    &@         _ -> @$y$@ }}@\\[4pt]
 %\\
 (d)&@case @$v$@ of { ~@$p$@ -> @$e$@; _ -> @$e'$@ }@\\
-&$=$@ (\@$x'_1$ $\ldots$ $x'_n$ @->@ $e_1$ @) (case @$v$@ of { @$p$@->@ 
+&$=$@ (\@$x_1$ $\ldots$ $x_n$ @->@ $e$ @) (case @$v$@ of { @$p$@->@ 
 $x_1$@ })@ $\ldots$ @(case @$v$@ of { @$p$@ -> @$x_n$@})@\\
-&{\rm where $e_1$ = $e\,[x'_1/x_1, \ldots, x'_n/x_n]$}\\[2pt]
-&{\rm $x_1, \ldots, x_n$ are all the variables in $p\/$; $x'_1, \ldots, x'_n$ are new variables}\\[4pt]
+&{\rm where $x_1, \ldots, x_n$ are all the variables in $p\/$}\\[4pt]
 %\\
 (e)&@case @$v$@ of { @$x${\tt @@}$p$@ -> @$e$@; _ -> @$e'$@ }@\\
 &$=$@  case @$v$@ of { @$p$@ -> ( \ @$x$@ -> @$e$@ ) @$v$@ ; _ -> @$e'$@ }@\\[4pt]
@@ -1455,7 +1557,7 @@ $x_1$@ })@ $\ldots$ @(case @$v$@ of { @$p$@ -> @$x_n$@})@\\
 &{\rm at least one of $p_1, \ldots, p_n$ is not a variable; $x_1, \ldots, x_n$ are new variables}\\[4pt]
 %\\
 (h)&@case @$v$@ of { @$k$@ -> @$e$@; _ -> @$e'$@ } @$=$@ if (@$v$@==@$k$@) then @$e$@ else @$e'$ \\
-&{\rm where $k$ is a character, string, or numeric literal.} \\[4pt]
+&{\rm where $k$ is a numeric, character, or string literal.} \\[4pt]
 %\\
 (i)&@case @$v$@ of { @$x$@ -> @$e$@; _ -> @$e'$@ } @$=$@ case @$v$@ of { @$x$@ -> @$e$@ }@\\[4pt]
 %\\
@@ -1491,15 +1593,15 @@ $e'$ @ }@ \\
 &{\rm where $K$ and $K'$ are distinct @data@ constructors of arity $n$ and $m$, respectively}\\[4pt]
 %\\
 (q)&@case (@$K$@ @$e_1$@ @$\ldots$@ @$e_n$@) of { @$K$@ @$x_1$@ @$\ldots$@ @$x_n$@ -> @$e$@; _ -> @$e'$@ }@\\
-&$=$@  case @$e_1$@ of { @$x'_1$@ -> @$\ldots$@  case @$e_n$@ of { @$x'_n$@ -> @$e[x'_1/x_1 \ldots x'_n/x_n]$@ }@$\ldots$@}@\\
-&{\rm where $K$ is a constructor of arity $n$; $x'_1 \ldots x'_n$ are new variables}\\[4pt]
+&$=~(@\@x_1 \ldots x_n@ -> @e)~e_1 ~\ldots~ e_n$\\
+&{\rm where $K$ is a @data@ constructor of arity $n$}\\[4pt]
 
 (r)&@case@~$\bot$~@of { @$K$@ @$x_1$@ @$\ldots$@ @$x_n$@ -> @$e$@; _ -> @$e'$@ }@ ~$=$~ $\bot$ \\
-&{\rm where $K$ is a constructor of arity $n$; $x'_1 \ldots x'_n$ are new variables}\\[4pt]
+&{\rm where $K$ is a @data@ constructor of arity $n$}\\[4pt]
 
 (s)&@case @$v$@ of { @$x$@+@$k$@ -> @$e$@; _ -> @$e'$@ }@\\
-&$=$@ if @$v$@ >= @$k$@ then @(\$x'$@ -> @$e[x'/x]$)~($v$@-@$k$)@ else @$e'$\\
-&{\rm where $k$ is a numeric literal, and $x'$ is a new variable}\\
+&$=$@ if @$v$@ >= @$k$@ then @(@\@$x$@ -> @$e$)~($v$@-@$k$)@ else @$e'$\\
+&{\rm where $k$ is a numeric literal}\\
 \end{tabular}
 }
 %**<div align=center> <h4>Figure 4</h4> </div>
@@ -1547,7 +1649,7 @@ meaning of pattern matching against overloaded constants.
 %% expressions, but doing so 
 %% would clutter the identities, which are intended only to convey the semantics.
 
-These identities all preserve the static semantics.  Rules~(d),~(e), (j), and~(s)
+These identities all preserve the static semantics.  Rules~(d),~(e), (j), (q), and~(s)
 use a lambda rather than a @let@; this indicates that variables bound
 by @case@ are monomorphically typed (Section~\ref{type-semantics}).
 \index{monomorphic type variable}
index 8309518..c501998 100644 (file)
@@ -20,6 +20,11 @@ L.~Damas and R.~Milner.
 \newblock In {\em Proceedings of the 9th ACM Symposium on Principles of
   Programming Languages}, pages 207--212, Albuquerque, N.M., January 1982.
 
+\bibitem{faxen:static}
+K-F. Fax\'en
+\newblock A static semantics for Haskell
+\newblock {\em Journal of Functional Programming}, 2002.
+
 \bibitem{hindley69}
 J.R.~Hindley.
 \newblock The principal type scheme of an object in combinatory logic.
@@ -37,17 +42,17 @@ Mark~P. Jones.
   higher-order polymorphism.
 \newblock {\em Journal of Functional Programming}, 5(1), January 1995.
 
+\bibitem{jones:thih}
+Mark~P. Jones.
+\newblock Typing Haskell in Haskell.
+\newblock {\em Haskell Workshop}, Paris, October 1999.
+
 \bibitem{penfield:complex-apl}
 P.~Penfield, Jr.
 \newblock Principal values and branch cuts in complex {APL}.
 \newblock In {\em APL '81 Conference Proceedings}, pages 248--256, San
   Francisco, September 1981.
 
-\bibitem{libraries}
-Simon Peyton Jones (editor).
-\newblock {S}tandard {L}ibraries for the {H}askell 98 {P}rogramming {L}anguage, 
-\newblock 2001.
-
 \bibitem{peyton-jones:book}
 S.L. Peyton~Jones.
 \newblock {\em The Implementation of Functional Programming Languages}.
index aed5cae..a3d7dfd 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/haskell.verb,v 1.12 2001/12/21 16:00:24 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/haskell.verb,v 1.13 2002/12/02 11:22:01 simonpj Exp $
 %
 
 % NOTE:--------------------------------------------------------------
 {\LARGE\bf Programming Language} \\[.3in]
 {\huge\bf Haskell 98} \\[.3in]
 {\Large\bf A Non-strict, Purely Functional Language} \\[.3in]
-{\large\bf Revised: December 2001}
+{\large\bf Revised: Sept 2002}
 \end{center}
 \vspace{.15in}
 \begin{center} \large
 \begin{tabular}{l@@{\hspace{5mm}}l}
-Simon Peyton Jones$^8$ [editor] & Lennart Augustsson$^9$ \\
-Dave Barton$^7$                & Brian Boutel$^4$ \\
-Warren Burton$^5$              & Joseph Fasel$^6$ \\
-Kevin Hammond$^2$              & Ralf Hinze$^{12}$  \\
-Paul Hudak$^1$                         & John Hughes$^3$ \\
-Thomas Johnsson$^3$            & Mark Jones$^{14}$ \\
+Simon Peyton Jones$^8$ [editor] & John Hughes$^3$ [editor] \\
+Lennart Augustsson$^3$         & Dave Barton$^7$ \\
+Brian Boutel$^4$               & Warren Burton$^5$ \\
+Joseph Fasel$^6$               & Kevin Hammond$^2$ \\
+Ralf Hinze$^{12}$              & Paul Hudak$^1$ \\
+Thomas Johnsson$^3$            & Mark Jones$^9$ \\
 John Launchbury$^{14}$                 & Erik Meijer$^{10}$ \\
-John Peterson$^1$              & Alastair Reid$^{15}$ \\
+John Peterson$^1$              & Alastair Reid$^1$ \\
 Colin Runciman$^{13}$          & Philip Wadler$^{11}$
 \end{tabular}
 \end{center}
@@ -454,18 +454,17 @@ Authors' affiliations:
 (6)~Los Alamos National Laboratory
 (7)~Intermetrics
 (8)~Microsoft Research, Cambridge
-(9)~Sandburst Corporation
-(10)~Microsoft Corporation
-(11)~Avaya Labs
+(9)~University of Nottingham
+(10)~Utrecht University
+(11)~Bell Labs
 (12)~University of Bonn
 (13)~York University
 (14)~Oregon Graduate Institute
-(15)~University of Utah
 \end{quotation}
 \vspace{.2in}
 
 \begin{center}
-Copyright (c) Simon Peyton Jones. 
+Copyright (c) Simon Peyton Jones and John Hughes
 \end{center}
 {\em The authors intend this Report to belong to the entire Haskell
 community, and so we grant permission to copy and distribute it for
@@ -555,7 +554,9 @@ a definition of the language Haskell 98.}
 \input{standard-prelude}\startnewsection
 %\input{libraries}\startnewsection
 \input{syntax-iso}\startnewsection
-\input{literate}\startnewsection
+
+% Literate stuff included in syntax-iso now
+% \input{literate}\startnewsection
 %% \input{short_semantics}\startnewsection
 %%\input{iosemant}\startnewsection
 %%\input{iooptions}\startnewsection
index 8974bf7..19d02dc 100644 (file)
@@ -26,7 +26,7 @@ style=article
 ~nxt=<a href="~next.html">next</a>
 ~funct=<a href="prelude-index.html">function index</a>
 ~contents=<a href="index98.html">contents</a>
-~foot=<br><font size=2>December 2001</font>
+~foot=<br><font size=2>Sept 2002</font>
 ~footer=<hr>~id~top | ~back | ~nxt | ~contents | ~funct ~foot
 ~sfooter=<hr>~id~top | back | ~nxt | ~contents | ~funct ~foot
 ~efooter=<hr>~id~top | ~back | next | ~contents | ~funct ~foot
index 226cf85..8e06229 100644 (file)
@@ -1,6 +1,4 @@
 Index entries that refer to nonterminals in the \Haskell{} syntax are
-shown in an "italic" font.  Code entities defined in the standard
-prelude (Appendix~\ref{stdprelude}) or in the \Haskell{} Library
-Report\cite{libraries}
+shown in an "italic" font.  Code entities 
 are shown in @typewriter@ font.  Ordinary index entries are
 shown in a roman font.
index 7046835..6b5dd21 100644 (file)
@@ -5,13 +5,14 @@
 <img src="h98.gif" alt="Haskell 98">
 
 <h3>Haskell 98: A Non-strict, Purely Functional Language</h3>
-<h3 align="center">Revised: December 2001</h3>
+<h3 align="center">Revised: Sept 2002</h3>
 </div>
 <hr>
 <h3>Brief Table of Contents</h3>
 <ul>
 <li><a href="index98.html">Full Table of Contents</a>
 <li><a href="preface-13.html">Preface</a>
+
 <li><a href="intro.html">Introduction</a>
 <li><a href="lexemes.html">Lexical Structure</a>
 <li><a href="exps.html">Expressions</a>
@@ -24,6 +25,7 @@
 <li><a href="literate.html">Literate Comments</a>
 <li><a href="derived.html">Derived Instances</a>
 <li><a href="pragmas.html">Pragmas</a>
+
 <li><a href="haskell.html">Bibliography</a>
 <li><a href="prelude-index.html">Index of Prelude Functions and Types</a>
 </ul>
@@ -71,7 +73,7 @@ Copyright (c) Simon Peyton Jones.
 <br>
 <em> The authors intend this Report to belong to the entire Haskell
 community, and so we grant permission to copy and distribute it for
-any purpose, provided that it is reproduced in its entirity,
+any purpose, provided that it is reproduced in its entirety,
 including this Notice. Modified versions of this Report may also be
 copied and distributed for any purpose, provided that the modified
 version is clearly presented as such, and that it does not claim to be
index b08bd01..7799b0a 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/intro.verb,v 1.3 2001/09/10 11:09:37 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/intro.verb,v 1.4 2002/12/02 11:22:01 simonpj Exp $
 %
 %**<title>The Haskell 98 Report: Introduction</title>
 %*section 1
@@ -17,7 +17,7 @@ system, a monadic I/O system, and a rich set of primitive datatypes,
 including lists,
 arrays, arbitrary and fixed precision integers, and floating-point
 numbers.  \Haskell{} is both the culmination
-and solidification of many years of research on lazy functional
+and solidification of many years of research on non-strict functional
 languages.
 
 % Although the initial emphasis was on standardization, \Haskell{}
index 7b40c97..d4fc1b6 100644 (file)
@@ -103,8 +103,11 @@ the user's terminal).
 \indextt{getChar}%
 \indextt{getLine}%
 \indextt{getContents}%
-Both @getChar@ and @getLine@ raise an exception (Section~\ref{io-exceptions}) on end-of-file; a 
+The @getChar@ operation raises an exception (Section~\ref{io-exceptions}) on end-of-file; a 
 predicate @isEOFError@ that identifies this exception is defined in the @IO@ library.
+The @getLine@ operation raises an exception under the same circumstances as @hGetLine@, 
+defined the @IO@ library.
+
 The @getContents@ operation returns all user input as a single
 string, which is read lazily as it is needed.  The @interact@
 function takes a function of type 
@@ -119,7 +122,8 @@ except that it signals parse failure to the I/O monad instead of
 terminating the program.  The @readLn@ function combines @getLine@ and
 @readIO@.
 
-By default, these input functions echo to standard output.  
+% Removed after extended debate on the Haskell mailing list.
+% By default, these input functions echo to standard output.  
 
 % Functions in the I/O library provide full control over echoing.
 % Lies, all lies
index 05ce5ed..a00d9ae 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/lexemes.verb,v 1.10 2001/12/21 16:00:25 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/lexemes.verb,v 1.11 2002/12/02 11:22:02 simonpj Exp $
 %
 %*section 2
 %**<title>Haskell 98 Lexical Structure</title>
@@ -71,12 +71,13 @@ However, source
 programs are currently biased toward the ASCII character set
 \index{ASCII character set} used in earlier versions of \Haskell{}.
 
-Haskell uses a pre-processor to convert non-Unicode character sets into
-Unicode.  This pre-processor converts all characters to Unicode and
-uses the escape sequence @\u@"hhhh", where the @"h"@ are hex digits,
-to denote escaped Unicode characters.  Since this translation occurs
-before the program is compiled, escaped Unicode characters may appear in
-identifiers and any other place in the program.
+%      Removed Sept 02
+% Haskell uses a pre-processor to convert non-Unicode character sets into
+% Unicode.  This pre-processor converts all characters to Unicode and
+% uses the escape sequence @\u@"hhhh", where the @"h"@ are hex digits,
+% to denote escaped Unicode characters.  Since this translation occurs
+% before the program is compiled, escaped Unicode characters may appear in
+% identifiers and any other place in the program.
 
 This syntax depends on properties of the Unicode characters as defined
 by the Unicode consortium. 
@@ -89,12 +90,15 @@ new versions of Unicode as they are made available.
 
 \input{syntax-lexical}
 
-Lexical analysis should use the ``maximal munch'' rule.
-At each point, the longest possible lexeme
-satisfying the "lexeme" production is read
+Lexical analysis should use the ``maximal munch'' rule:
+at each point, the longest possible lexeme
+satisfying the "lexeme" production is read.
 \index{maximal munch rule}
-using a context-independent deterministic lexical analysis
-(i.e.~no lookahead beyond the current character is required).
+% using a context-independent deterministic lexical analysis
+% (i.e.~no lookahead beyond the current character is required).
+% Not so -- consider the input "F. 9. 0o 0x 9.0e+f", which 
+% should lex as "F . 9 . 0 o 0 x 9.0 e + f" but that needs up 
+% to 2 additional characters of lookahead.  
 So, although @case@ is a reserved word, @cases@ is not.
 Similarly, although @=@ is reserved, @==@ and @~=@ are
 not.  
index fd07b40..3837a47 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/modules.verb,v 1.16 2001/12/21 16:00:25 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/modules.verb,v 1.17 2002/12/02 11:22:02 simonpj Exp $
 %
 %**<title>The Haskell 98 Report: Modules</title>
 %*section 5
@@ -75,7 +75,7 @@ beginning with a capital letter; i.e.~"modid").
 There is one distinguished module, @Prelude@, which is imported into
 all modules by default (see Section~\ref{standard-prelude}), plus a
 set of standard library modules that may be imported as required
-(see the \Haskell{} Library Report\cite{libraries}).
+(see the \Haskell{} Library Report).
 
 \subsection{Module Structure} 
 \label{module-implementations}
@@ -163,7 +163,8 @@ construction of abstract datatypes (see Section~\ref{abstract-types}).
 \item
 The form $T@(@c_1@,@\ldots@,@c_n@)@$, 
 names the type and some or all of its constructors and field names.  
-The subordinate names $c_i$ must not contain duplicates.  
+% Restriction removed March 02:
+% The subordinate names $c_i$ must not contain duplicates.  
 \item
 The abbreviated form "T@(..)@" names the type 
 and all its constructors and field names that are currently in scope
@@ -199,7 +200,9 @@ declared in a @class@ declaration may be named in one of three ways:
 The form "C" names the class {\em but not the class methods}.
 \item
 The form $C@(@f_1@,@\ldots@,@f_n@)@$, names the class and some or all
-of its methods.  The subordinate names $f_i$ must not contain duplicates.
+of its methods.  
+% Restriction removed March 02:
+% The subordinate names $f_i$ must not contain duplicates.
 \item
 The abbreviated form $C@(..)@$ names the class and all its methods
 that are in scope (whether qualified or not).
@@ -211,10 +214,10 @@ is in scope in the module body regardless of whether it is in scope
 under a qualified or unqualified name.
 
 \item
-The form ``@module M@'' abbreviates the set of all entities whose
-{\em unqualified} name, $e$, is in scope, and for which the {\em qualified} name
-$M.e$ is also in scope and refers to the same entity as $e$.  This set
-may be empty.
+The form ``@module M@'' names the set of all entities that are in
+scope with both an unqualified name ``@e@'' and a qualified name
+``@M.e@''.
+This set may be empty.
 For example:
 \bprog
 @
@@ -263,11 +266,11 @@ The {\em unqualified} names of the entities exported by a module must all be dis
   g = f True
 @
 \eprog
-There are name clashes in the export list 
-between @C.g@ and @g@, 
-and between @module B@ and @C.f@ (assuming @B.f@ and @C.f@ are different entities), 
-even though there are no name clashes within module @A@ itself.  
-
+There are no name clashes within module @A@ itself, 
+but there are name clashes in the export list between @C.g@ and @g@
+(assuming @C.g@ and @g@ are different entities -- remember, modules
+can import each other recursively), and between @module B@ and @C.f@
+(assuming @B.f@ and @C.f@ are different entities).
 
 \subsection{Import Declarations}
 \label{import}
@@ -280,7 +283,7 @@ impspec   -> @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ & (n>=0)
              |  @hiding@ @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ & (n>=0)
 
 import    -> var
-         |  tycon [ @(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] &  (n>=1)
+         |  tycon [ @(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] &  (n>=0)
          |  tycls [@(..)@ | @(@ var_1 @,@ ... @,@ var_n @)@] & (n>=0)
 cname     -> var | con
 @@@
@@ -383,11 +386,11 @@ name as a qualified import:
 \bprog
 @
   module Ring where
-  import qualified Prelude  -- All Prelude names must be qualified
+  import qualified Prelude    -- All Prelude names must be qualified
   import List( nub )
 
-  l1 + l2 = l1 ++ l2        -- This + differs from the one in the Prelude
-  l1 * l2 = nub (l1 + l2)   -- This * differs from the one in the Prelude
+  l1 + l2 = l1 Prelude.++ l2  -- This + differs from the one in the Prelude
+  l1 * l2 = nub (l1 + l2)     -- This * differs from the one in the Prelude
 
   succ = (Prelude.+ 1)
 @
@@ -450,7 +453,7 @@ Import declaration & Names brought into scope \\
   @import qualified A hiding ()@       & @A.x@, @A.y@ \\
   @import qualified A hiding (x)@      & @A.y@ \\
   @import A as B@              & @x@, @y@, @B.x@, @B.y@ \\
-  @import A as B(x)@           & @B.x@ \\
+  @import A as B(x)@           & @x@, @B.x@ \\
   @import qualified A as B@    & @B.x@, @B.y@ \\
 \hline
 \end{tabular}
@@ -584,7 +587,7 @@ the following module is legal:
 The local declaration for @sin@ is
 legal, even though the Prelude function @sin@ is implicitly in
 scope. The references to @Prelude.sin@ and @F.sin@ must both be qualified
-to make it unambigous which @sin@ is meant. However, the unqualified
+to make it unambiguous which @sin@ is meant. However, the unqualified
 name "@sin@" in the type signature in the first line of @F@ unambiguously
 refers to the local declaration for @sin@.
 
@@ -653,8 +656,8 @@ many predefined library modules, which provide less frequently used
 functions and types.  For example, arrays, 
 tables, and most of the input/output are all part of the standard
 libraries.    These are 
-defined in the Haskell Library Report\cite{libraries},
-a separate document.  Separating
+defined in the Haskell Library Report.
+Separating
 libraries from the Prelude has the advantage of reducing the size and
 complexity of the Prelude, allowing it to be more easily assimilated,
 and increasing the space of useful names available to the programmer.
@@ -728,20 +731,23 @@ affect the meaning of these special constructs.  For example, in
 \bprog
 @
   module B where
-    import qualified Prelude
+    import Prelude()
     import MyPrelude
-      ...
+    f x = (x,x)
+    g x = (,) x x
+    h x = [x] ++ []
 @
 \eprog
-@B@ imports nothing from @Prelude@, but the
-explicit @import qualified Prelude@ declaration prevents the automatic
-import of 
-@Prelude@.  @import MyPrelude@ brings the
-non-standard prelude into scope.  As before, the
-standard prelude names are hidden explicitly.  Special
-syntax, such as lists or tuples, always refers to prelude entities:
-there is no way to redefine the meaning of @[x]@ in terms of a
+the explicit @import Prelude()@ declaration prevents the automatic
+import of @Prelude@, while the declaration @import MyPrelude@ brings the
+non-standard prelude into scope.  
+The special syntax for tuples (such as @(x,x)@ and @(,)@) and lists
+(such as @[x]@ and @[]@) continues to refer to the tuples and lists
+defined by the standard @Prelude@;
+there is no way to redefine the meaning of @[x]@, for example, in terms of a
 different implementation of lists.
+On the other hand, the use of @++@ is not special syntax, so it refers
+to @++@ imported from @MyPrelude@.
 
 It is not possible, however, to hide @instance@ declarations in the
 @Prelude@.  For example, one cannot define a new instance for @Show Char@.
index 576a720..f31cb7f 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/plain_haskell.verb,v 1.3 2001/08/23 16:41:41 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/plain_haskell.verb,v 1.4 2002/12/02 11:22:02 simonpj Exp $
 %
 
 % NOTE:--------------------------------------------------------------
@@ -468,7 +468,7 @@ Copyright (c) Simon Peyton Jones and John Hughes.
 \end{center}
 {\em The authors intend this Report to belong to the entire Haskell
 community, and so we grant permission to copy and distribute it for
-any purpose, provided that it is reproduced in its entirity,
+any purpose, provided that it is reproduced in its entirety,
 including this Notice. Modified versions of this Report may also be
 copied and distributed for any purpose, provided that the modified
 version is clearly presented as such, and that it does not claim to be
index 1ea52cd..f6b81e1 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/preface-13.verb,v 1.11 2001/11/02 16:26:48 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/preface-13.verb,v 1.12 2002/12/02 11:22:02 simonpj Exp $
 %
 %**<title>The Haskell 98 Report: Preface</title>
 %*section
@@ -229,6 +229,15 @@ Haskell 1.4.
 \item Contributed Haskell tools and libraries.
 \item Applications of Haskell.
 \end{itemize}
+Particularly relevant to this Report are the following two papers:
+\begin{itemize}
+\item ``A static semantics for Haskell'' (Faxen) gives a formal presentation
+of Haskell's type system \cite{faxen:static}.
+\item 
+``Typing Haskell in Haskell'' (Jones) gives a type inference algorithm for Haskell,
+written in Haskell \cite{jones:thih}.
+\end{itemize}
+
 We welcome your comments, suggestions, and criticisms on the language
 or its presentation in the report, via the Haskell mailing list.
 
@@ -267,6 +276,7 @@ Thomas Hallgren,
 Matt Harden,
 Klemens Hemm,
 Fergus Henderson,
+Dean Herington,
 Ralf Hinze,
 Bob Hiromoto,
 Nic Holt,
@@ -317,7 +327,7 @@ Bjarte M. {\O}stvold,
 Paul Otto, 
 Sven Panne,
 Dave Parrott,
-Ross Patterson,
+Ross Paterson,
 Larne Pekowsky,
 Rinus Plasmeijer,
 Ian Poole,
index 0d18c3a..ed7cd19 100644 (file)
@@ -46,7 +46,7 @@ functional programming language called \Haskell{},
 named after the logician Haskell B.~Curry\index{Curry, Haskell B.}
 whose work provides the logical basis for much of ours.
 
-\subsection{Goals}
+\section*{Goals}
 
 The committee's primary goal was to design a language that
 satisfied these constraints:
@@ -62,41 +62,41 @@ satisfied these constraints:
       programming languages.
 \end{enumerate}
 
-\subsection{Haskell 98: language and libraries}
+\section*{\Haskell{} 98: language and libraries}
 
 The committee intended that \Haskell{} would serve as a basis for
 future research in language design, and hoped that extensions or
 variants of the language would appear, incorporating experimental
 features.
 
-Haskell has indeed evolved continuously since its original publication.
+\Haskell{} has indeed evolved continuously since its original publication.
 By the middle of 1997, there had been four iterations of the language design
-(the latest at that point being Haskell 1.4).  At the 1997 Haskell Workshop 
-in Amsterdam, it was decided that a stable variant of Haskell was needed;
-this stable language is the subject of this Report, and is called ``Haskell 98''.
+(the latest at that point being \Haskell{} 1.4).  At the 1997 \Haskell{} Workshop 
+in Amsterdam, it was decided that a stable variant of \Haskell{} was needed;
+this stable language is the subject of this Report, and is called ``\Haskell{} 98''.
 
-Haskell 98 was conceived as a relatively minor tidy-up of Haskell 1.4, making
+\Haskell{} 98 was conceived as a relatively minor tidy-up of \Haskell{} 1.4, making
 some simplifications, and removing some pitfalls for the unwary. It is intended to
 be a ``stable'' language in sense the {\em implementors are committed to supporting
-Haskell 98 exactly as specified, for the foreseeable future}.
+\Haskell{} 98 exactly as specified, for the foreseeable future}.
 
-The original Haskell Report covered only the language, together with a
-standard library called the @Prelude@.  By the time Haskell 98 was
+The original \Haskell{} Report covered only the language, together with a
+standard library called the @Prelude@.  By the time \Haskell{} 98 was
 stabilised, it had become clear that many programs need access to a
 larger set of library functions (notably concerning input/output and
 simple interaction with the operating system).  If these program were
 to be portable, a set of libraries would have to be standardised too.
 A separate effort was therefore begun by a distinct (but overlapping)
-committee to fix the Haskell 98 Libraries.  
+committee to fix the \Haskell{} 98 Libraries.  
 
-The Hsakell 98 Language and Library Reports were published in February 1999.
+The \Haskell{} 98 Language and Library Reports were published in February 1999.
 
-\subsection{Revising the Haskell 98 Reports}
+\section*{Revising the \Haskell{} 98 Reports}
 
 After a year or two, many typographical errors and infelicities had been
 spotted.  I took on the role of gathering and acting on these corrections,
 with the following goals:
-\begim{itemize}
+\begin{itemize}
 \item Correct typographical errors.
 \item Clarify obscure passages.
 \item Resolve ambiguities.
@@ -104,28 +104,28 @@ with the following goals:
 consistent.
 \end{itemize}
 This task turned out to be much, much larger than I had anticipated.
-As Haskell becomes more widely used, the Report has been scrutinised by more
+As \Haskell{} becomes more widely used, the Report has been scrutinised by more
 and more people, and I have adopted hundreds of (mostly small) changes as 
 a result of their feedback.
-The original committees ceased to exist when the original Haskell 98 Reports were 
-published, so every change was instead proposed to the entire Haskell mailing list.
+The original committees ceased to exist when the original \Haskell{} 98 Reports were 
+published, so every change was instead proposed to the entire \Haskell{} mailing list.
 
 This document is the outcome of this process of refinement.
-It includes both the Haskell 98 Language Report and the Libraries Report,
+It includes both the \Haskell{} 98 Language Report and the Libraries Report,
 and constitutes the official specification of both.
 It is {\em not} a tutorial on programming in
 \Haskell{} such as the `Gentle Introduction' \cite{tutorial}, and some
 familiarity with functional languages is assumed. 
 
-The entire text of both Reports is available online (see Section~\ref{sect:resources}).
+The entire text of both Reports is available online (see ``\Haskell{} resources'' below).
 
 
-\subsection{Extensions to Haskell 98}
+\section*{Extensions to \Haskell{} 98}
 
-Haskell continues to evolve, going well beyond Haskell 98.  For example, at the
-time of writing there are Haskell implementations that support:
+\Haskell{} continues to evolve, going well beyond \Haskell{} 98.  For example, at the
+time of writing there are \Haskell{} implementations that support:
 \begin{description}
-\item[Syntactic sugar, including:]
+\item[Syntactic sugar,] including:
 \begin{itemize}
 \item pattern guards; 
 \item recursive do-notation;
@@ -133,7 +133,7 @@ time of writing there are Haskell implementations that support:
 \item meta-programming facilities;
 \end{itemize}
 
-\item[Type system innovations, including:]
+\item[Type system innovations,] including:
 \begin{itemize}
 \item multi-parameter type classes;
 \item functional dependencies;
@@ -141,7 +141,7 @@ time of writing there are Haskell implementations that support:
 \item local universal polymorphism and arbitrary rank-types;
 \end{itemize}
 
-\item[Control extensions, including:]
+\item[Control extensions,] including:
 \begin{itemize}
 \item monadic state;
 \item exceptions;
@@ -149,17 +149,15 @@ time of writing there are Haskell implementations that support:
 \end{itemize}
 \end{description}
 
-There is more besides.  Haskell 98 does not impede these developments.
+There is more besides.  \Haskell{} 98 does not impede these developments.
 Instead, it provides a stable point of reference, so that those who
-wish to write text books, or use Haskell for teaching, can do so in
-the knowledge that Haskell 98 will continue to exist.  On the few
-occasions when we refer to the evolving, future version of Haskell, we
-call it ``Haskell 2''.
+wish to write text books, or use \Haskell{} for teaching, can do so in
+the knowledge that \Haskell{} 98 will continue to exist.  
 
-\subsection{\Haskell{} Resources}
+\section*{\Haskell{} Resources}
 \label{sect:resources}
 
-The Haskell web site
+The \Haskell{} web site
 \bprog
 @
        http://haskell.org
@@ -168,20 +166,20 @@ The Haskell web site
 gives access to many useful resources, including:
 \begin{itemize}
 \item Online versions of the language and library definitions, including
-a complete list of all the differences between Haskell 98 as published in February 1999
+a complete list of all the differences between \Haskell{} 98 as published in February 1999
 and this revised version. 
-\item Tutorial material on Haskell.
-\item Details of the Haskell mailing list.
-\item Implementations of Haskell.
-\item Contributed Haskell tools and libraries.
-\item Applications of Haskell.
+\item Tutorial material on \Haskell{}.
+\item Details of the \Haskell{} mailing list.
+\item Implementations of \Haskell{}.
+\item Contributed \Haskell{} tools and libraries.
+\item Applications of \Haskell{}.
 \end{itemize}
-We welcome your comments, suggestions, and criticisms on the language
-or its presentation in the report, via the Haskell mailing list.
+You are welcome to comment on, suggest improvements to, and criticise the language
+or its presentation in the report, via the \Haskell{} mailing list.
 
-\subsection{Building the language}
+\section*{Building the language}
 
-Haskell was created, and continues to be sustained, by an active community of 
+\Haskell{} was created, and continues to be sustained, by an active community of 
 researchers and application programmers.  Those who served on the Language and
 Library committees, in particular, devoted a huge amount of time and energy to the
 language.  Here they are, with their affiliation(s) for the relevant period:
@@ -194,14 +192,14 @@ Brian Boutel (Victoria University of Wellington) \\
 Warren Burton (Simon Fraser University) \\
 Jon Fairbairn (University of Cambridge) \\
 Joseph Fasel (Los Alamos National Laboratory) \\
-Andy Gordon (University of Cambridge?) \\
+Andy Gordon (University of Cambridge) \\
 Maria Guzman (Yale University) \\
 Kevin Hammond (Uniiversity of Glasgow) \\
-Ralf Hinze {University of Bonn) \\
+Ralf Hinze (University of Bonn) \\
 Paul Hudak [editor] (Yale University) \\
 John Hughes [editor] (University of Glasgow; Chalmers University) \\
 Thomas Johnsson (Chalmers University) \\
-Mark Jones (Nottingham University) \\
+Mark Jones (Yale University, University of Nottingham, Oregon Graduate Institute) \\
 Dick Kieburtz (Oregon Graduate Institute) \\
 John Launchbury (University of Glasgow; Oregon Graduate Institute) \\
 Erik Meijer (Utrecht University) \\
@@ -251,13 +249,14 @@ Thomas Hallgren,
 Matt Harden,
 Klemens Hemm,
 Fergus Henderson,
+Dean Herington,
 Ralf Hinze,
 Bob Hiromoto,
 Nic Holt,
 Ian Holyer, 
 Randy Hudson,
 Alexander Jacobson,
-Patrick Jansson,
+Patrik Jansson,
 Robert Jeschofnik,
 Orjan Johansen,
 Simon B.~Jones, 
@@ -266,7 +265,7 @@ Mike Joy,
 Stefan Kahrs,
 Antti-Juhani Kaijanaho,
 Jerzy Karczmarczuk,
-Wolfram Karl,
+Wolfram Kahl,
 Kent Karlsson,
 Richard Kelsey,
 Siau-Cheng Khoo, 
@@ -277,7 +276,8 @@ Marcin Kowalczyk,
 Jose Labra,
 Jeff Lewis,
 Mark Lillibridge,
-Bjorn Lisper,
+% The doubled "" is turned into one by the verbatim preprocessor
+Bj\""{o}rn Lisper,
 Sandra Loosemore,
 Pablo Lopez,
 Olaf Lubeck, 
@@ -289,12 +289,12 @@ Michael Marte,
 Jim Mattson,
 John Meacham,
 Sergey Mechveliani,
-Erik Meijer,
 Gary Memovich,
 Randy Michelsen, 
 Rick Mohr,
 Andy Moran,
 Graeme Moss,
+Henrik Nilsson,
 Arthur Norman,
 Nick North,
 Chris Okasaki,
@@ -302,7 +302,7 @@ Bjarte M. {\O}stvold,
 Paul Otto, 
 Sven Panne,
 Dave Parrott,
-Ross Patterson,
+Ross Paterson,
 Larne Pekowsky,
 Rinus Plasmeijer,
 Ian Poole,
@@ -319,6 +319,7 @@ Libor Skarvada,
 Jan Skibinski,
 Lauren Smith, 
 Raman Sundaresh,
+Josef Svenningsson,
 Ken Takusagawa,
 Satish Thatte,
 Simon Thompson,
@@ -338,28 +339,20 @@ Stuart Wray,
 and Bonnie Yantis.
 
 Finally, aside from the important foundational work laid by Church,
-Rosser, Curry, and others on the lambda calculus, we wish to
+Rosser, Curry, and others on the lambda calculus, it is right to
 acknowledge the influence of many noteworthy programming languages
 developed over the years.  Although it is difficult to pinpoint the
-origin of many ideas, we particularly wish to acknowledge the
-influence of Lisp (and its modern-day incarnations Common Lisp and
+origin of many ideas, the following languages were particularly influential:
+Lisp (and its modern-day incarnations Common Lisp and
 Scheme); Landin's ISWIM; APL; Backus's FP
 \cite{back78}; ML and Standard ML; Hope and Hope$^{+}$; Clean; Id; Gofer;
 Sisal; and Turner's series of languages culminating in 
-Miranda.\footnote{{\rm Miranda} is a trademark of Research
-Software Ltd.} Without these forerunners \Haskell{} would not have
+Miranda\footnote{{\rm Miranda} is a trademark of Research
+Software Ltd.}. Without these forerunners \Haskell{} would not have
 been possible.
 
-\subsection{Copyright}
-
-The publisher intends this Report to belong to the entire Haskell
-community, and grants permission to copy and distribute it for any
-\emph{non-commercial} purpose, provided that it is reproduced in its
-entirety, including this Notice. Modified versions of this Report may
-also be copied and distributed for any \emph{non-commercial} purpose,
-provided that the modified version is clearly presented as such, and
-that it does not claim to be a definition of the language Haskell 98.
-
-Where a commercial purpose is involved, contact Cambridge University Press.
+\vspace{1in}
 
+Simon Peyton Jones \\
+Cambridge, September 2002
 %**~sfooter
index e53f8b3..61a69d5 100644 (file)
@@ -151,10 +151,10 @@ class                             #TShow a       #S6.3.3
 #VfloatRange       :: RealFloat a => a -> (Int, Int) 
 #Vfloor            :: (RealFrac a, Integral b) => a -> b 
 #Vfmap             :: Functor f => (a -> b) -> f a -> f b
-#Vfoldl            :: (a -> b -> a) -> a -> [b] -> a #&foldl (+) 0 [a,b,c] = ((a+b)+c)+0
+#Vfoldl            :: (a -> b -> a) -> a -> [b] -> a #&foldl (+) 0 [a,b,c] = ((0+a)+b)+c
 #Vfoldl1           :: (a -> a -> a) -> [a] -> a #&foldl1 (+) [a,b,c] = (a+b)+c
-#Vfoldr            :: (a -> b -> b) -> b -> [a] -> b #&foldr (+) 0 [a,b,c] = 0+(a+(b+c))
-#Vfoldr1           :: (a -> a -> a) -> [a] -> a #&foldr (+) [a,b,c] = a+(b+c)
+#Vfoldr            :: (a -> b -> b) -> b -> [a] -> b #&foldr (+) 0 [a,b,c] = a+(b+(c+0))
+#Vfoldr1           :: (a -> a -> a) -> [a] -> a #&foldr1 (+) [a,b,c] = a+(b+c)
 #VfromEnum         :: Enum a => a -> Int 
 #VfromInteger      :: Num a => Integer -> a #&#S3.2
 #VfromIntegral     :: (Integral a, Num b) => a -> b
index 9b1aa54..804f023 100644 (file)
@@ -1,10 +1,10 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/syntax-iso.verb,v 1.8 2001/12/21 16:00:25 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/syntax-iso.verb,v 1.9 2002/12/02 11:22:02 simonpj Exp $
 %
 %**<title>Haskell 98 Syntax</title>
 %*section B
 %**~header
-\section{Syntax}
+\section{Syntax Reference}
 \label{syntax}
 \index{syntax}
 
@@ -161,11 +161,19 @@ the token "\{n\}" is inserted after the keyword, where "n" is the indentation of
 next lexeme if there is one, or "0" if the end of file has been reached.
 \item If the first lexeme of a module is not @{@ or @module@, 
 then it is preceded by "\{n\}" where "n" is the indentation of the lexeme. 
-\item Where the start of a lexeme does not follow a complete lexeme on the
+\item Where the start of a lexeme is preceded only by white space on the
    same line, this lexeme is preceded by "<n>" where "n"
    is the indentation of the lexeme, provided that it is not,
    as a consequence of the first two rules, preceded by "\{n\}".
-   (A string literal may span multiple lines -- Section~\ref{lexemes-char}.)
+   (NB: a string literal may span multiple lines -- Section~\ref{lexemes-char}.  So in the fragment
+\bprog
+@
+  f = ("Hello \
+          \Bill", "Jake")
+@
+\eprog
+There is no "<n>" inserted before the "@\Bill@", because it is not the beginning of
+a complete lexeme; nor before the "@,@", because it is not preceded only by white space.)
 \end{itemize}
 
 \item A stack of ``layout contexts'', in which each element is either:
@@ -191,6 +199,8 @@ enough spaces to align the current position with the next tab stop.
 \end{itemize}
 For the purposes of the layout rule, Unicode characters in a source program
 are considered to be of the same, fixed, width as an ASCII character.
+However, to avoid visual confusion, programmers should avoid writing programs in which 
+the meaning of implicit layout depends on the width of non-space characters.
 
 The application
 \[
@@ -309,6 +319,106 @@ is valid, because it translates to
 @
 \eprog
 The close brace is inserted due to the parse error rule above.
+The parse-error rule is hard to implement in its full generality, because 
+doing so involves fixities.  For example, the expression
+\bprog
+@
+  do a == b == c
+@
+\eprog
+has a single unambiguous (albeit probably type-incorrect) parse, namely
+\bprog
+@
+  (do { a == b }) == c
+@
+\eprog
+because @(==)@ is non-associative.   Programmers are therefore advised to avoid
+writing code that requires the parser to insert a closing brace in such
+situations.
+
+
+\startnewsection
+\subsection{Literate comments}
+\label{literate}
+\index{literate comments}
+
+The ``literate comment''
+convention, first developed by Richard Bird and Philip Wadler for
+Orwell, and inspired in turn by Donald Knuth's ``literate
+programming'', is an alternative style for encoding \Haskell{} source
+code. 
+The literate style encourages comments by making them the default.  A
+line in which ``@>@'' is the first character is treated as part of the
+program; all other lines are comment.
+
+The program text is recovered
+by taking only those lines beginning with ``@>@'', 
+and replacing the leading ``@>@'' with a space.
+Layout and comments apply
+exactly as described in Appendix~\ref{syntax} in the resulting text.
+
+To capture some cases where one omits an ``@>@'' by mistake, it is an
+error for a program line to appear adjacent to a non-blank comment line,
+where a line is taken as blank if it consists only of whitespace.
+
+By convention, the style of comment is indicated by the file
+extension, with ``@.hs@'' indicating a usual Haskell file and
+``@.lhs@'' indicating a literate Haskell file.  Using this style, a
+simple factorial program would be:
+\bprog
+@
+   This literate program prompts the user for a number
+   and prints the factorial of that number:
+
+> main :: IO ()
+
+> main = do putStr "Enter a number: "
+>           l <- readLine
+>           putStr "n!= "
+>           print (fact (read l))
+          
+  This is the factorial function.
+
+> fact :: Integer -> Integer
+> fact 0 = 1
+> fact n = n * fact (n-1)
+@
+\eprog
+
+
+An alternative style of literate programming is particularly
+suitable for use with the LaTeX text processing system.
+In this convention, only those parts of the literate program that are
+entirely enclosed between @\begin{code}@$\ldots$@\end{code}@ delimiters are
+treated as program text; all other lines are comment.  More precisely:
+\begin{itemize}
+\item Program code begins on the first line following a line that begins @\begin{code}@.
+\item Program code ends just before a subsequent line that begins @\end{code}@ (ignoring
+string literals, of course).
+\end{itemize}
+It is not necessary
+to insert additional blank lines before or after these delimiters, though
+it may be stylistically desirable.  For example,
+\bprog
+@
+\documentstyle{article}
+
+\begin{document}
+
+\section{Introduction}
+
+This is a trivial program that prints the first 20 factorials.
+
+\begin{code}
+main :: IO ()
+main =  print [ (n, product [1..n]) | n <- [1..20]]
+\end{code}
+
+\end{document}
+@
+\eprog
+This style uses the same file extension.  It is not advisable to mix
+these two styles in the same file.
 
 \startnewsection
 \subsection{Context-Free Syntax}
@@ -346,7 +456,7 @@ impspec   -> @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ & (n>=0)
              |  @hiding@ @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ &  (n>=0)
 
 import    -> var
-         |  tycon [ @(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] & (n>=1)
+         |  tycon [ @(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] & (n>=0)
          |  tycls [@(..)@ | @(@ var_1 @,@ ... @,@ var_n @)@] & (n>=0)
 cname     -> var | con
 @@@
@@ -517,7 +627,9 @@ aexp        ->  qvar                                & (\tr{variable})
        |   @[@ exp_1 [@,@ exp_2] @..@ [exp_3] @]@ & (\tr{arithmetic sequence})
        |   @[@ exp @|@ qual_1 @,@ ... @,@ qual_n @]@   & (\tr{list comprehension}, n>=1)
        |   @(@ exp^{i+1} qop^{(a,i)} @)@        & (\tr{left section})
-        |   @(@ qop^{(a,i)} exp^{i+1} @)@        & (\tr{right section})
+       |   @(@ lexp^{i} qop^{(l,i)} @)@        & (\tr{left section})
+        |   @(@ qop^{(a,i)}_{\langle@-@\rangle}  exp^{i+1} @)@        & (\tr{right section})
+        |   @(@ qop^{(r,i)}_{\langle@-@\rangle}  rexp^{i} @)@        & (\tr{right section})
         |   qcon @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled construction}, n>=0)
         |   aexp_{\langle{}qcon\rangle{}} @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled update}, n >= 1)
 @@@
@@ -539,7 +651,7 @@ stmts -> stmt_1 ... stmt_n exp [@;@]  &  (n>=0)
 stmt -> exp @;@
       | pat @<-@ exp @;@
       | @let@ decls @;@
-      | @;@                    & (empty statment)
+      | @;@                    & (empty statement)
 
 fbind   ->  qvar @=@ exp
         
index 75d81cb..9d79c6e 100644 (file)
@@ -1,5 +1,5 @@
 %
-% $Header: /home/cvs/root/haskell-report/report/syntax-lexical.verb,v 1.7 2001/12/21 16:00:25 simonpj Exp $
+% $Header: /home/cvs/root/haskell-report/report/syntax-lexical.verb,v 1.8 2002/12/02 11:22:02 simonpj Exp $
 % 
 
 @@@
@@ -12,9 +12,8 @@ special               -> @(@ | @)@ | @,@ | @;@ | @[@ | @]@ | \bkq | @{@ | @}@
 
 whitespace     -> whitestuff \{whitestuff\}
 whitestuff     -> whitechar | comment | ncomment
-whitechar      -> newline | return | linefeed | vertab | formfeed
-                 | space | tab | uniWhite
-newline                -> \tr{a newline (system dependent)}
+whitechar      -> newline | vertab | space | tab | uniWhite
+newline        -> return linefeed | return | linefeed | formfeed
 return         -> \tr{a carriage return}
 linefeed       -> \tr{a line feed}
 vertab         -> \tr{a vertical tab}
@@ -29,7 +28,7 @@ opencom               -> @{-@
 closecom       -> @-}@
 ncomment       -> opencom ANYseq \{ncomment ANYseq\} closecom
 ANYseq         -> \{ANY\}_{\langle{}\{ANY\} ( opencom | closecom ) \{ANY\}\rangle{}}
-ANY            -> any | newline | vertab | formfeed | return | linefeed | uniWhite
+ANY            -> grahic | whitechar
 any            -> graphic | space | tab
 graphic                -> small | large | symbol | digit | special | @:@ | @"@ | @'@
 
index 0065eba..1a3039f 100644 (file)
@@ -978,6 +978,7 @@ texCommands = [("\\",doEol),
 -- For the tutorial:
                ("see",doSee),
 -- For mpj:
+              ("in", emitSymc 8712),
                ("ts",ignore 0),
                ("la",use "<"),
                ("ra",use ">"),