diff6-10.chapter6.txt

このページは最後に更新されてから1年以上経過しています。情報が古い可能性がありますので、ご注意ください。

last mod. 2008-11-01 (土) 10:51:56
4a5
> 
18a20
> 
44a47
> 
52a56
> 
56c60,61
<                    ident ::=  (letter|_) { letter|0...9|_|' } 
---
>                  ident ::=  (letter| _) { letter| 0...9| _| ' } 
>                                                                 
62,65c67,71
< current implementation (except on MacOS) also recognizes as letters all
< accented characters from the ISO 8859-1 (``ISO Latin 1'') set. All characters
< in an identifier are meaningful. The current implementation places no limits on
< the number of characters of an identifier.
---
> current implementation also recognizes as letters all accented characters from
> the ISO 8859-1 ("ISO Latin 1") set. All characters in an identifier are
> meaningful. The current implementation accepts identifiers up to 16000000
> characters in length.
>   
70,85c76,83
<                                               [+]                    
<                                               ---                    
<            integer-literal ::=   [-] { 0...9 }[ ]                    
<                                               ---                    
<                                                                  [+] 
<                                                                  --- 
<                              |  [-] (0x|0X) { 0...9|A...F|a...f }[ ] 
<                                                                  --- 
<                                                      [+]             
<                                                      ---             
<                              |  [-] (0o|0O) { 0...7 }[ ]             
<                                                      ---             
<                                                      [+]             
<                                                      ---             
<                              |  [-] (0b|0B) { 0...1 }[ ]             
<                                                      ---             
---
>   integer-literal ::=  [-] (0...9) { 0...9| _ }                                
>                                           
>                       |   [-] (0x| 0X) (0...9| A...F| a...f) { 0...9| A...F|
>                                   a...f| _ } 
>                    |   [-] (0o| 0O) (0...7) { 0...7| _ }                       
>                                           
>                    |   [-] (0b| 0B) (0...1) { 0...1| _ }                       
>                                           
91,97c89,95
<                         -------------------------------
<                         |Prefix|        Radix         |
<                         -------------------------------
<                         |0x, 0X|hexadecimal (radix 16)|
<                         |0o, 0O|octal (radix 8)       |
<                         |0b, 0B|binary (radix 2)      |
<                         -------------------------------
---
>                        --------------------------------
>                        |Prefix |        Radix         |
>                        --------------------------------
>                        | 0x, 0X|hexadecimal (radix 16)|
>                        |0o, 0O |octal (radix 8)       |
>                        |0b, 0B |binary (radix 2)      |
>                        --------------------------------
100a99,101
>   For convenience and readability, underscore characters (_) are accepted (and
> ignored) within integer literals.
>   
105,112c106,107
<                                    [+]                                      [+]
<                                         
<                                    ---                                      ---
<                                         
<    float-literal ::=   [-] { 0...9 }[ ] [. { 0...9 }]  [(e|E) [+|-] { 0...9 }[
<                                       ]] 
<                                    ---                                      ---
<                                         
---
>    float-literal ::=  [-] (0...9) { 0...9| _ } [. { 0...9| _ }] [(e| E) [+| -]
>                             (0...9) { 0...9| _ }] 
121a117,119
>   For convenience and readability, underscore characters (_) are accepted (and
> ignored) within floating-point literals.
>   
127a126
>                                                                           
129a129
>                        |   \x (0...9| A...F| a...f) (0...9| A...F| a...f) 
135c135
<             -------------------------------------------------------
---
>           ----------------------------------------------------------
137,138c137,138
<             -------------------------------------------------------
<             |\\      |backslash (\)                               |
---
>           ----------------------------------------------------------
>           | \\     |backslash (\)                                  |
145,146c145,149
<             |\ddd    |the character with ASCII code ddd in decimal|
<             -------------------------------------------------------
---
>           |\space  |space (SPC)                                    |
>           |\ddd    |the character with ASCII code ddd in decimal   |
>           |\xhh    |the character with ASCII code hh in hexadecimal|
>           ----------------------------------------------------------
>   
152a156
>                                                                 
164a169
> 
171,172c176,178
<                   label  ::=  ~ (a ... z) { letter|0...9|_|' } : 
<                optlabel  ::=  ? (a ... z) { letter|0...9|_|' } : 
---
>                label  ::=  ~ (a ... z| _) { letter| 0...9| _| ' } : 
>                                                                     
>             optlabel  ::=  ? (a ... z| _) { letter| 0...9| _| ' } : 
177a184
> 
181,182c188,191
<     infix-symbol ::=   (= | < | > | @ | ^ | | | & |  + | - | * | / | $ | %) {
<                                operator-char }  
---
>    infix-symbol ::=  (= |  < |  > |  @ |  ^ |  | |  & |  + |  - |  * |  / |  $
>                          |  %) { operator-char }      
>                                                                                
>                                                      
185,186d193
<   operator-char ::=   ! | $ | % | & | * | + | - | . |  / | : | < | = | > | ? |
<                                 @ |  ^ | | | ~ 
188c195,201
<   Sequences of ``operator characters'', such as <=> or !!, are read as a single
---
>                                                      
>   operator-char ::=  ! |  $ |  % |  & |  * |  + |  - |  . |  / |  : |  < |  = |
>                           > |  ? |  @ |  ^ |  | |  ~ 
>                                                                                
>                                                      
>   
>   Sequences of "operator characters", such as <=> or !!, are read as a single
192a206
> 
198,202c212,215
< <<
<         and         as          assert      asr         begin       class
<         closed      constraint  do          done        downto      else
<         end         exception   external    false       for         fun
<         function    functor     if          in          include     inherit
---
> <<      and         as          assert      asr         begin       class
>         constraint  do          done        downto      else        end
>         exception   external    false       for         fun         function
>         functor     if          in          include     inherit     initializer
205c218
<         new         of          open        or          parser      private
---
>         new         object      of          open        or          private
211,215c224,227
< <<
<       #     &     '     (     )     *     ,     ->    ?
<       ??    .     ..    .(    .[    :     ::    :=    ;
<       ;;    <-    =     [     [|    [<    {<    ]     |]
<       >]    >}    _     `     {     |     }     ~
---
> <<    !=    #     &     &&    '     (     )     *     +     ,     -
>       -.    ->    .     ..    :     ::    :=    :>    ;     ;;    <
>       <-    =     >     >]    >}    ?     ??    [     [<    [>    [|
>       ]     _     `     {     {<    |     |]    }     ~
216a229,233
>   Note that the following identifiers are keywords of the Camlp4 extensions and
> should be avoided for compatibility reasons. 
> <<    parser    <<    <:    >>    $     $$    $:
> >>
>   
222,225c239,242
<   Lexical ambiguities are resolved according to the ``longest match'' rule:
< when a character sequence can be decomposed into two tokens in several
< different ways, the decomposition retained is the one with the longest first
< token.
---
>   Lexical ambiguities are resolved according to the "longest match" rule: when
> a character sequence can be decomposed into two tokens in several different
> ways, the decomposition retained is the one with the longest first token.
>   
230,237c247,251
<                                             [+]                         
<                                             ---                         
<          linenum-directive ::=   # {0 ... 9}[ ]                         
<                                             ---                         
<                                            [+]                          
<                                            ---                          
<                              |  # {0 ... 9}[ ] " { string-character } " 
<                                            ---                          
---
>                                             +                          
>           linenum-directive ::=  # {0 ... 9}                           
>                                             +                          
>                              |   # {0 ... 9}  " { string-character } " 
>                                                                        
247a262
> 
259a275
> 
267a284
> 
275a293
> 
283a302
> 
288c307,308
< supports strings containing up to 2^24 - 6 characters (16777210 characters).
---
> supports strings containing up to 2^24 - 5 characters (16777211 characters); on
> 64-bit platforms, the limit is 2^57 - 9.
312,313c332,335
< current implementation supports arrays containing to 2^22 - 1 elements (4194303
< elements).
---
> current implementation supports arrays containing up to 2^22 - 1 elements
> (4194303 elements) unless the elements are floating-point numbers (2097151
> elements in this case); on 64-bit platforms, the limit is 2^54 - 1 for all
> arrays.
320,322c342,344
< constructor and a value. The former case is written cconstr; the latter case is
< written ncconstr(v), where v is said to be the argument of the non-constant
< constructor ncconstr.
---
> constructor and a value. The former case is written constr; the latter case is
> written constr(v), where v is said to be the argument of the non-constant
> constructor constr.
325c347
<                          -----------------------------
---
>                          ----------------------------
327,328c349,350
<                          -----------------------------
<                          |false   |the boolean false |
---
>                          ----------------------------
>                          | false  |the boolean false|
330c352
<                          |()      |the ``unit'' value|
---
>                          |()      |the "unit" value |
332c354
<                          -----------------------------
---
>                          ----------------------------
334,335c356,357
<   The current implementation limits the number of distinct constructors in a
< given variant type to at most 249.
---
>   The current implementation limits each variant type to have at most 246
> non-constant constructors.
370,371c392
<  - value constructors (constant -- class cconstr-name -- or non-constant --
<    class ncconstr-name), 
---
>  - value constructors and exception constructors (class constr-name), 
381c402
<    These nine name spaces are distinguished both by the context and by the
---
>    These eleven name spaces are distinguished both by the context and by the
387a409
> 
393,400c415,423
<       operator-name ::=   prefix-symbol | infix-symbol | * | = | or | & | := 
<        cconstr-name ::=   capitalized-ident                                  
<                       |  false                                               
<                       |  true                                                
<                       |  [ ]                                                 
<                       |  ( )                                                 
<       ncconstr-name ::=   capitalized-ident                                  
<                       |  ::                                                  
---
>                                                                            
>         operator-name ::=  prefix-symbol |  infix-op                       
>                                                                            
>              infix-op ::=  infix-symbol                                    
>                        |   * |  = |  or |  & |  :=                         
>                        |   mod |  land |  lor |  lxor |  lsl |  lsr |  asr 
>                                                                            
>           constr-name ::=  capitalized-ident                               
>                                                                            
401a425
>                                                                            
402a427
>                                                                            
403a429
>                                                                            
404a431
>                                                                            
405a433
>                                                                            
406a435
>                                                                            
407a437
>                                                                            
408a439
>                                                                            
411,413c442,443
< used as value names, provided they are written between parentheses. Keywords
< such as '::' and 'false' are also constructor names. The capitalization rules
< are summarized in the table below.
---
> used as value names, provided they are written between parentheses. The
> capitalization rules are summarized in the table below.
415c445
<                    ----------------------------------------
---
>                    -----------------------------------------
417,418c447,448
<                    ----------------------------------------
<                    |Values           |lowercase           |
---
>                    -----------------------------------------
>                    | Values           |lowercase           |
421,422c451,453
<                    |Variant tag      |uppercase           |
<                    |Type constructors|lowercase           |
---
>                    |Variant tags      |uppercase           |
>                    |Exceptions        |uppercase           |
>                    |Type constructors |lowercase           |
424a456
>                    |Instance variables|lowercase           |
428c460
<                    ----------------------------------------
---
>                    -----------------------------------------
433a466
> 
438,442c471,475
<                            |  module-path . lowercase-ident                 
<                  cconstr ::=   cconstr-name                                 
<                            |  module-path . capitalized-ident               
<                 ncconstr ::=   ncconstr-name                                
<                            |  module-path . capitalized-ident               
---
>                           |   module-path .  value-name                      
>                                                                              
>                   constr ::=  constr-name                                    
>                           |   module-path .  constr-name                     
>                                                                              
444c477,478
<                            |  extended-module-path . lowercase-ident        
---
>                           |   extended-module-path .  typeconstr-name        
>                                                                              
446c480,481
<                            |  module-path . lowercase-ident                 
---
>                           |   module-path .  field-name                      
>                                                                              
448c483,484
<                            |  module-path . capitalized-ident               
---
>                           |   module-path .  module-name                     
>                                                                              
450c486
<                            |  extended-module-path . capitalized-ident      
---
>                           |   extended-module-path .  module-name            
451a488
>                                                                              
453c490,491
<                            |  extended-module-path . ident                  
---
>                           |   extended-module-path .  modtype-name           
>                                                                              
455c493
<                            |  module-path . lowercase-ident                 
---
>                           |   module-path .  class-name                      
470a509
> 
479,483c518,520
<                           |  [[?]ident:] typexpr -> typexpr           
<                                                   [+]                 
<                                                   ---                 
<                           |  typexpr { * typexpr }[ ]                 
<                                                   ---                 
---
>                         |   [[?]label-name:]  typexpr ->  typexpr      
>                                                   +                    
>                         |   typexpr  { * typexpr }                     
488c525
<                           |  [ variant-type ]                         
---
>                         |   variant-type                               
493a531
>                                                                        
495,498c533,535
<                                         [+]                           
<                                         ---                           
<                           |  { ' ident }[ ] . typexpr                 
<                                         ---                           
---
>                                        +                               
>                         |   { ' ident }  .  typexpr                    
>                                                                        
505c542
<                  --------------------------------------------
---
>                  ---------------------------------------------
507,508c544,545
<                  --------------------------------------------
<                  |Type constructor application|--           |
---
>                  ---------------------------------------------
>                  | Type constructor application|--           |
512c549
<                  --------------------------------------------
---
>                  ---------------------------------------------
516a554
> 
525,526c563,572
< variable is the whole enclosing definition; they can only be generalized when
< leaving this scope. Anonymous variables have no such restriction.
---
> variable is the whole enclosing definition; and they can only be generalized
> when leaving this scope. Anonymous variables have no such restriction. In the
> following cases, the scope of named type variables is restricted to the type
> expression where they appear: 1) for universal (explicitly polymorphic) type
> variables; 2) for type variables that only appear in public method
> specifications (as those variables will be made universal, as described in
> section 6.9.1); 3) for variables used as aliases, when the type they are
> aliased to would be invalid in the scope of the enclosing definition (i.e. when
> it contains free universal type variables, or locally defined types.)
>   
532a579
> 
538,540c585,587
<   label typexpr_1 -> typexpr_2 denotes the same function type, but the argument
< is labeled label.
<   ?label typexpr_1 -> typexpr_2 denotes the type of functions mapping an
---
>   label-name :  typexpr_1 ->  typexpr_2 denotes the same function type, but the
> argument is labeled label.
>   optlabel  typexpr_1 ->  typexpr_2 denotes the type of functions mapping an
543a591
> 
549a598
> 
557,559c606,609
<   The type expression (typexpr_1,...,typexpr_n) typeconstr, where typeconstr is
< a type constructor with n parameters, denotes the application of the n-ary type
< constructor typeconstr to the types typexpr_1 through typexpr_n.
---
>   The type expression (typexpr_1,..., typexpr_n)  typeconstr, where typeconstr
> is a type constructor with n parameters, denotes the application of the n-ary
> type constructor typeconstr to the types typexpr_1 through typexpr_n.
>   
566,570c616,621
< also binds the type variable ident to type typexpr both in typexpr and in the
< remaining part of the type. If the type variable ident actually occurs in
< typexpr, a recursive type is created. Recursive types for which there exists a
< recursive path that does not contain an object or variant type constructor are
< rejected, except when the -rectypes mode is selected.
---
> also binds the type variable ident to type typexpr both in typexpr and in other
> types. In general the scope of an alias is the same as for a named type
> variable, and covers the whole enclosing definition. If the type variable ident
> actually occurs in typexpr, a recursive type is created. Recursive types for
> which there exists a recursive path that does not contain an object or variant
> type constructor are rejected, except when the -rectypes mode is selected.
574a626
> 
578c630
<    variant-type ::=   [ | ] tag-spec { | tag-spec }                            
---
>    variant-type ::=  [ [ | ] tag-spec  { | tag-spec } ]                        
580c632
<                   |  > [ tag-spec ] { | tag-spec }                             
---
>                  |   [> [ tag-spec ]  { | tag-spec } ]                         
583c635,637
<                                     [+]   
---
>                                       +     
>                      |   [< [ | ] tag-spec-full  { | tag-spec-full }  [ > {
>                                `tag-name }  ] ] 
585,587d638
<                                     ---   
<                   |  < [ | ] tag-spec-full { | tag-spec-full } [ > { `tag-name
<                                     }[ ] ] 
589d639
<                                     ---   
593a644,645
>                                                                                
>                                             
598a651,652
>                                             
>   
623a678
> 
627c682,683
<   An object type < method-type { ; method-type } > is a record of method types.
---
>   An object type < method-type  { ; method-type } > is a record of method
> types.
632,633c688,689
<   The type < method-type { ; method-type } ; .. > is the type of an object with
< methods and their associated types are described by method-type_1, ...,
---
>   The type < method-type  { ; method-type } ; .. > is the type of an object
> with methods and their associated types are described by method-type_1, ..., 
637a694
> 
652a710
> 
669c727,731
<                                     |  cconstr          
---
>                                    |   constr          
>                                    |   false           
>                                    |   true            
>                                    |   []              
>                                    |   ()              
674c736,737
< constructors from both normal and polymorphic variants.  
---
> constructors from both normal and polymorphic variants, as well as the special
> constants false, true, [], and (), which behave like constant constructors.  
688c751
<                        |  ncconstr pattern                          
---
>                     |   constr  pattern                              
701c764
<                     ---------------------------------------
---
>                    ----------------------------------------
703,704c766,767
<                     ---------------------------------------
<                     |Constructor application|--           |
---
>                    ----------------------------------------
>                    | Constructor application|--           |
709c772
<                     ---------------------------------------
---
>                    ----------------------------------------
713,715c776,779
< operation is called pattern matching; its outcome is either ``this value does
< not match this pattern'', or ``this value matches this pattern, resulting in
< the following bindings of names to values''.
---
> operation is called pattern matching; its outcome is either "this value does
> not match this pattern", or "this value matches this pattern, resulting in the
> following bindings of names to values".
>   
726a791
> 
732a798
> 
740a807
> 
746c813
< ). This constraint forces the type of pattern_1 to be compatible with type.
---
> ). This constraint forces the type of pattern_1 to be compatible with typexpr.
748,749d814
< ``Or'' patterns
< ---------------
751c816,819
<   The pattern pattern_1 | pattern_2 represents the logical ``or'' of the two
---
> "Or" patterns
> -------------
>   
>   The pattern pattern_1 |  pattern_2 represents the logical "or" of the two
755,758c823,827
< the same types. The bindings performed by matching against an ``or'' pattern
< are either those performed by the matching against pattern_1, if it succeeds,
< or those performed by the matching against pattern_2, if it succeeds. If both
< matchings succeed, it is undefined which set of bindings is selected.
---
> the same types. Matching is performed from left to right. More precisely, in
> case some value v matches pattern_1 |  pattern_2, the bindings  performed are
> those of pattern_1 when v matches pattern_1. Otherwise, value v matches
> pattern_2 whose bindings are performed.
>   
763,764c832,833
<   The pattern ncconstr pattern_1 matches all variants whose constructor is
< equal to ncconstr, and whose argument matches pattern_1.
---
>   The pattern constr  pattern_1 matches all variants whose constructor is equal
> to constr, and whose argument matches pattern_1.
766,767c835
< pattern_1, and whose tails match pattern_2. This pattern behaves like ( :: ) (
< pattern_1 , pattern_2 ).
---
> pattern_1, and whose tails match pattern_2.
771a840
> 
777a847
> 
781,784c851,855
<   If the type [('a,'b,...)] typeconstr = [`tag_1 t_1 | ... | `tag_n t_n] is
< defined, then the pattern #typeconstr is a shorthand for the or-pattern
< (`tag_1(_ : t_1) | ... | `tag_n(_ : t_n)). It matches all values of type
< #typeconstr.
---
>   If the type [('a,'b,...)] typeconstr = [`tag_1  typexpr_1 | ... | `tag_n 
> typexpr_n] is defined, then the pattern #typeconstr is a shorthand for the
> or-pattern (`tag_1(_ : typexpr_1) | ... | `tag_n(_ :  typexpr_n)). It matches
> all values of type #typeconstr.
>   
793a865
> 
802a875
> 
806,807c879,881
<   The pattern [| pattern_1 ; ... ; pattern_n |] matches arrays of length n such
< that the i-th array element matches the pattern pattern_i, for i = 1,... , n.
---
>   The pattern [| pattern_1 ; ... ;  pattern_n |] matches arrays of length n
> such that the i-th array element matches the pattern pattern_i, for i = 1,... ,
> n.
815a890
>                                                 
816a892
>                                                 
817a894
>                                                 
818a896
>                                                 
819a898
>                                                 
821c900,902
<                  |  ncconstr expr                                         
---
>                                                 
>                      |   constr  expr                                          
>                                                 
822a904
>                                                 
823a906
>                                                 
824a908
>                                                 
825a910
>                                                 
826a912
>                                                 
828,831c914,918
<                                      [+]                                  
<                                      ---                                  
<                  |  expr { argument }[ ]                                  
<                                      ---                                  
---
>                                                 
>                                            +                                   
>                                                 
>                      |   expr  { argument }                                    
>                                                 
832a920
>                                                 
833a922
>                                                 
834a924
>                                                 
835a926
>                                                 
836a928
>                                                 
837a930
>                                                 
838a932
>                                                 
839a934
>                                                 
840a936
>                                                 
841a938
>                                                 
842a940
>                                                 
843a942
>                                                 
844a944
>                                                 
845a946
>                                                 
846a948
>                                                 
847a950
>                                                 
848a952
>                                                 
849a954,956
>                                                 
>                      |   object class-body end                                 
>                                                 
850a958,962
>                                                 
>                      |   inst-var-name                                         
>                                                 
>                      |   inst-var-name <-  expr                                
>                                                 
851a964
>                                                 
853c966,974
<                  |  {< inst-var-name = expr { ; inst-var-name = expr } >} 
---
>                                                 
>                      |   {< inst-var-name =  expr  { ; inst-var-name =  expr }
>                               >}                 
>                      |   assert expr                                           
>                                                 
>                      |   lazy expr                                             
>                                                 
>                                                                                
>                                                 
854a976
>                                                 
855a978
>                                                 
856a980
>                                                 
857a982
>                                                 
860,862d984
<    pattern-matching ::=   [ | ] pattern [when expr] -> expr  { | pattern [when
<                                expr] -> expr } 
<                                        [+]                                     
864d985
<                                        ---                                     
866c987,989
<   multiple-matching ::=   { parameter }[ ] [when expr] -> expr                 
---
>      pattern-matching ::=  [ | ] pattern  [when expr] ->  expr  { | pattern 
>                             [when expr] ->  expr } 
>                                                                                
868c991
<                                        ---                                     
---
>                                       +                                        
870c993
<         let-binding ::=   pattern [: typexpr] = expr                           
---
>   multiple-matching ::=  { parameter }   [when expr] ->  expr                  
872d994
<                                                  [+]                           
874d995
<                                                  ---                           
876c997,1000
<                       |  value-name { parameter }[ ] [: typexpr] = expr        
---
>         let-binding ::=  pattern =  expr                                       
>                                                 
>                      |   value-name  { parameter }  [: typexpr] =  expr        
>                                                 
878d1001
<                                                  ---                           
896,899d1018
<            infix-op ::=   infix-symbol                                         
<                                                
<                       |  * | = | or | &                                        
<                                                
903,904c1022,1023
< first. For infix and prefix symbols, we write ``*...'' to mean ``any symbol
< starting with *''. 
---
> first. For infix and prefix symbols, we write "*..." to mean "any symbol
> starting with *". 
906c1025
<      ---------------------------------------------------------------------
---
>   ---------------------------------------------------------------------------
908,909c1027,1028
<      ---------------------------------------------------------------------
<      |prefix-symbol                                        |--           |
---
>   ---------------------------------------------------------------------------
>   | prefix-symbol                                             |--           |
911,912c1030
<      |function application                                 |left         |
<      |constructor application                              |--           |
---
>   |function application, constructor application, assert, lazy|left         |
914,916c1032,1034
<      |**...                                                |right        |
<      |*...   /...   %...   mod                             |left         |
<      |+...   -...                                          |left         |
---
>   |**...   lsl   lsr   asr                                    |right        |
>   |*...   /...   %...   mod   land   lor   lxor               |left         |
>   | +...   -...                                               |left         |
918,920c1036,1037
<      |@...^...                                             |right        |
<      |comparisons (=  ==  <  etc.), all other infix symbols|left         |
<      |not                                                  |--           |
---
>   |@...   ^...                                                |right        |
>   |comparisons (=  ==  <  etc.), all other infix symbols      |left         |
928c1045
<      ---------------------------------------------------------------------
---
>   ---------------------------------------------------------------------------
935a1053
> 
940a1059
> 
947a1067
> 
958,961c1078,1083
<   Parenthesized expressions can contain a type constraint, as in ( expr : type
< ). This constraint forces the type of expr to be compatible with type.
<   Parenthesized expressions can also contain coercions ( expr [: type] :> type)
< (see subsection 6.7.5 below).
---
>   Parenthesized expressions can contain a type constraint, as in ( expr : 
> typexpr ). This constraint forces the type of expr to be compatible with
> typexpr.
>   Parenthesized expressions can also contain coercions ( expr  [: typexpr] :> 
> typexpr) (see subsection 6.7.5 below).
>   
993a1116
> 
999,1004c1122,1124
<                                         [ ]        [ ] 
<                                         ---        --- 
<                                         [ ]        [ ] 
<                         function pattern--- -> expr--- 
<                                         [1]        [1] 
<                                         ---        --- 
---
>                                                      
>                           function pattern  -> expr  
>                                           1        1 
1006,1011c1126,1128
<                                         [ ]        [ ] 
<                                         ---        --- 
<                                         [ ]        [ ] 
<                                | pattern--- -> expr--- 
<                                         [n]        [n] 
<                                         ---        --- 
---
>                                                      
>                                  | pattern  -> expr  
>                                           n        n 
1030,1042c1147,1149
<                                                                            [ ] 
<                                            
<                                                                            --- 
<                                            
<                                                                            [ ] 
<                                            
<   fun optlabel x ->  let pattern =  match x with Some x -> x | None -> expr--- 
<                                    in expr 
<                                                                            [0] 
<                                            
<                                                                            --- 
<                                            
<    where x is a fresh variable. When expr_0 will be evaluated is left
---
>      fun optlabel  ident -> let  pattern = match  ident with Some  ident -> 
>                        ident | None ->  expr_0 in  expr 
>    where ident is a fresh variable. When expr_0 will be evaluated is left
1055a1163
> 
1063,1068c1171,1173
<                                [ ]               [ ]         [ ] 
<                                ---               ---         --- 
<                                [ ]               [ ]         [ ] 
<                function pattern---   [when   cond---] -> expr--- 
<                                [1]               [1]         [1] 
<                                ---               ---         --- 
---
>                                                               
>                  function pattern    [when   cond ]  -> expr  
>                                  1               1          1 
1070,1075c1175,1177
<                                [ ]               [ ]         [ ] 
<                                ---               ---         --- 
<                                [ ]               [ ]         [ ] 
<                       | pattern---   [when   cond---] -> expr--- 
<                                [n]               [n]         [n] 
<                                ---               ---         --- 
---
>                                                               
>                         | pattern     [when   cond ] -> expr  
>                                  n                n         n 
1083a1186
> 
1109,1110c1212,1213
< one of the patterns pattern_1, ..., pattern_n, and expect them to have the same
< value as in expr, the body of the let rec construct.
---
> one of the patterns pattern_1, ...,  pattern_n, and expect them to have the
> same value as in expr, the body of the let rec construct.
1119,1124c1222,1223
< class of recursive definitions of non-functional values, such as 
<           let rec name_1 = 1 :: name_2 and name_2 = 2 :: name_1 in expr 
<    which binds name_1 to the cyclic list 1::2::1::2::..., and name_2 to the
< cyclic list 2::1::2::1::...Informally, the class of accepted definitions
< consists of those definitions where the defined names occur only inside
< function bodies or as argument to a data constructor.
---
> class of recursive definitions of non-functional values, as explained in
> section 7.3.
1130a1230
> 
1136a1237
> 
1144a1246
> 
1150,1155c1252,1254
<                                        [ ]        [ ] 
<                                        ---        --- 
<                                        [ ]        [ ] 
<                            with pattern--- -> expr--- 
<                                        [1]        [1] 
<                                        ---        --- 
---
>                                                     
>                              with pattern  -> expr  
>                                          1        1 
1157,1162c1256,1258
<                                        [ ]        [ ] 
<                                        ---        --- 
<                                        [ ]        [ ] 
<                               | pattern--- -> expr--- 
<                                        [n]        [n] 
<                                        ---        --- 
---
>                                                     
>                                 | pattern  -> expr  
>                                          n        n 
1170a1267
> 
1181,1185c1278,1282
<   The expression expr_1 || expr_2 evaluates to true if one of expr_1 and expr_2
< evaluates to true; otherwise, it evaluates to false. The first component,
< expr_1, is evaluated first. The second component, expr_2, is not evaluated if
< the first component evaluates to true. Hence, the expression expr_1 || expr_2
< behaves  exactly as 
---
>   The expression expr_1 ||  expr_2 evaluates to true if one of expr_1 and
> expr_2 evaluates to true; otherwise, it evaluates to false. The first
> component, expr_1, is evaluated first. The second component, expr_2, is not
> evaluated if the first component evaluates to true. Hence, the expression
> expr_1 ||  expr_2 behaves  exactly as 
1190a1288
> 
1194,1197c1292,1295
<    The expression while expr_1 do expr_2 done repeatedly evaluates expr_2 while
< expr_1 evaluates to true. The loop condition expr_1 is evaluated and tested at
< the beginning of each iteration. The whole while ... done expression evaluates
< to the unit value ().
---
>    The expression while expr_1 do  expr_2 done repeatedly evaluates expr_2
> while expr_1 evaluates to true. The loop condition expr_1 is evaluated and
> tested at the beginning of each iteration. The whole while ... done expression
> evaluates to the unit value ().
1201,1202c1299,1300
< is successively bound to the values  n, n+1, ..., p-1, p.  The loop body is
< never evaluated if n > p.
---
> is successively bound to the values n, n+1, ..., p-1, p. The loop body is never
> evaluated if n > p.
1207a1306
> 
1213,1218c1312,1314
<                                       [ ]        [ ] 
<                                       ---        --- 
<                                       [ ]        [ ] 
<                           with pattern--- -> expr--- 
<                                       [1]        [1] 
<                                       ---        --- 
---
>                                                    
>                             with pattern  -> expr  
>                                         1        1 
1220,1225c1316,1318
<                                       [ ]        [ ] 
<                                       ---        --- 
<                                       [ ]        [ ] 
<                              | pattern--- -> expr--- 
<                                       [n]        [n] 
<                                       ---        --- 
---
>                                                    
>                                | pattern  -> expr  
>                                         n        n 
1235c1328
< thereby transparently ``passing through'' the try construct.
---
> thereby transparently "passing through" the try construct.
1241a1335
> 
1248a1343
> 
1252,1253c1347,1348
<   The expression ncconstr expr evaluates to the variant value whose constructor
< is ncconstr, and whose argument is the value of expr.
---
>   The expression constr  expr evaluates to the variant value whose constructor
> is constr, and whose argument is the value of expr.
1255,1257c1350,1352
< stands for the constructor ( :: )  applied to the argument ( expr_1 , expr_2 ),
< and therefore evaluates to the list whose head is the value of expr_1 and whose
< tail is the value of expr_2. The expression [ expr_1 ; ... ; expr_n ] is
---
> stands for the constructor ( :: )  applied to the argument ( expr_1 ,  expr_2
> ), and therefore evaluates to the list whose head is the value of expr_1 and
> whose tail is the value of expr_2. The expression [ expr_1 ; ... ;  expr_n ] is
1260a1356
> 
1266a1363
> 
1270,1282c1367,1379
<   The expression { field_1 = expr_1 ; ... ; field_n = expr_n } evaluates to the
< record value { field_1 = v_1 ; ... ; field_n = v_n }, where v_i is the value of
< expr_i for i = 1,... , n. The fields field_1 to field_n must all belong to the
< same record types; all fields belonging to this record type must appear exactly
< once in the record expression, though they can appear in any order. The order
< in which expr_1 to expr_n are evaluated is not specified.
<   The expression { expr with field_1 = expr_1 ; ... ; field_n = expr_n } builds
< a fresh record with fields field_1 ... field_n equal to expr_1 ... expr_n, and
< all other fields having the same value as in the record expr. In other terms,
< it returns a shallow copy of the record expr, except for the fields field_1 ...
< field_n, which are initialized to expr_1 ... expr_n.
<   The expression expr_1 . field evaluates expr_1 to a record value, and returns
< the value associated to field in this record value.
---
>   The expression { field_1 =  expr_1 ; ... ;  field_n =  expr_n } evaluates to
> the record value { field_1 = v_1; ...; field_n = v_n } where v_i is the value
> of expr_i for i = 1,... , n. The fields field_1 to field_n must all belong to
> the same record types; all fields belonging to this record type must appear
> exactly once in the record expression, though they can appear in any order. The
> order in which expr_1 to expr_n are evaluated is not specified.
>   The expression { expr with  field_1 =  expr_1 ; ... ;  field_n =  expr_n }
> builds a fresh record with fields field_1 ...  field_n equal to expr_1 ... 
> expr_n, and all other fields having the same value as in the record expr. In
> other terms, it returns a shallow copy of the record expr, except for the
> fields field_1 ...  field_n, which are initialized to expr_1 ...  expr_n.
>   The expression expr_1 .  field evaluates expr_1 to a record value, and
> returns the value associated to field in this record value.
1288a1386
> 
1304a1403
> 
1329c1428
< expr_2.
---
>  expr_2.
1338c1437
<                |+          |Integer addition.                 |
---
>                | +         |Integer addition.                 |
1344,1346c1443
<                |           |argument is zero. The result is   |
<                |           |unspecified if either argument is |
<                |           |negative.                         |
---
>                |           |argument is zero.                 |
1349,1352c1446,1450
<                |           |argument is zero. The result is   |
<                |           |unspecified if either argument is |
<                |           |negative.                         |
<                |land       |Bitwise logical ``and'' on        |
---
>                |           |argument is zero.                 |
>                |land       |Bitwise logical "and" on integers.|
>                |           |                                  |
>                |lor        |Bitwise logical "or" on integers. |
>                |lxor       |Bitwise logical "exclusive or" on |
1354,1357d1451
<                |lor        |Bitwise logical ``or'' on         |
<                |           |integers.                         |
<                |lxor       |Bitwise logical ``exclusive or''  |
<                |           |on integers.                      |
1382,1385c1476,1479
<                |<          |Test ``less than''.               |
<                |<=         |Test ``less than or equal''.      |
<                |>          |Test ``greater than''.            |
<                |>=         |Test ``greater than or equal''.   |
---
>                |<          |Test "less than".                 |
>                |<=         |Test "less than or equal".        |
>                |>          |Test "greater than".              |
>                |>=         |Test "greater than or equal".     |
1393a1488
> 
1403a1499,1514
> 
> Immediate object creation
> -------------------------
>   
>   
>   Creating directly an object through the object class-body end construct is
> operationally equivalent to defining locally a class class-name = object 
> class-body end ---see sections 6.9.2 and following for the syntax of
> class-body--- and immediately creating a single object from it by new
> class-name.
>   The typing of immediate objects is slightly different from explicitely
> defining a class in two respects. First, the inferred object type may contain
> free type variables. Second, since the class body of an immediate object will
> never be extended, its self type can be unified with a closed object type.
>   
> 
1413a1525,1536
> 
> Accessing and modifying instance variables
> ------------------------------------------
>   
>   The instance variables of a class are visible only in the body of the methods
> defined in the same class or a class that inherits from the class defining the
> instance variables. The expression inst-var-name evaluates to the value of the
> given instance variable. The expression inst-var-name <-  expr assigns the
> value of expr to the instance variable inst-var-name, which must be mutable.
> The whole expression inst-var-name <-  expr evaluates to ().
>   
> 
1418,1419c1541,1542
< expression ( expr :> typexpr ) coerces the expression expr to type typexpr. The
< expression ( expr : typexpr_1 :> typexpr_2 ) coerces the expression expr from
---
> expression (expr :>  typexpr) coerces the expression expr to type typexpr. The
> expression (expr :  typexpr_1 :>  typexpr_2) coerces the expression expr from
1428a1552
> 
1433c1557
< 20.21 ). Inside a method, the expression  {< inst-var-name = expr { ;
---
> 20.21). Inside a method, the expression  {< inst-var-name =  expr  { ;
1454a1579,1580
>                                                                                
>                                            
1456a1583,1584
>                                                                                
>                                            
1458a1587,1588
>                                                                                
>                                            
1460a1591,1592
>                                                                                
>                                            
1464a1597,1598
>                                                                                
>                                            
1468a1603,1604
>                                                                                
>                                            
1475d1610
<           constr-decl ::=   cconstr-name                                       
1477c1612,1617
<                         |  ncconstr-name of typexpr                            
---
>                                            
>           constr-decl ::=  constr-name                                         
>                                            
>                        |   constr-name of  typexpr  { * typexpr }              
>                                            
>                                                                                
1482a1623,1624
>                                                                                
>                                            
1485a1628,1629
>                                            
>     
1494,1502c1638,1652
< constructors with one parameter, or a list of type variables
< ('ident_1,...,'ident_n), for type constructors with several parameters. Each
< type parameter may be prefixed by a variance constraint + (resp. -) indicating
< that the parameter is covariant (resp. contravariant). These type parameters
< can appear in the type expressions of the right-hand side of the definition,
< restricted eventually by a variance constraint ; i.e. a covariant parameter may
< only appear on the right side of a functional arrow (more precisely, follow the
< left branch of an even number of arrows), and a convariant parameter only the
< left side (left branch of an odd number of arrows).
---
> constructors with one parameter, or a list of type variables ('ident_1,...,'
> ident_n), for type constructors with several parameters. Each type parameter
> may be prefixed by a variance constraint + (resp. -) indicating that the
> parameter is covariant (resp. contravariant). These type parameters can appear
> in the type expressions of the right-hand side of the definition, restricted
> eventually by a variance constraint ; i.e. a covariant parameter may only
> appear on the right side of a functional arrow (more precisely, follow the left
> branch of an even number of arrows), and a contravariant parameter only the
> left side (left branch of an odd number of arrows). If the type has either a
> representation or an equation, and the parameter is free (i.e. not bound via a
> type constraint to a constructed type), its variance constraint is checked but
> subtyping etc. will use the inferred variance of the parameter, which may be
> better; otherwise (i.e. for abstract types or non-free parameters), the
> variance must be given explicitly, and the parameter is invariant if no
> variance was given.
1515,1518c1665,1668
< ncconstr-name of typexpr declares the name ncconstr-name as a non-constant
< constructor, whose argument has type typexpr. The constructor declaration
< cconstr-name declares the name cconstr-name as a constant constructor.
< Constructor names must be capitalized.
---
> constr-name of  typexpr_1, ...,  typexpr_n declares the name constr-name as a
> non-constant constructor, whose arguments have types typexpr_1 ...typexpr_n.
> The constructor declaration constr-name declares the name constr-name as a
> constant constructor. Constructor names must be capitalized.
1560c1710
< subtyping relations when checking the validity of >: coercions (see section
---
> subtyping relations when checking the validity of :> coercions (see section
1586,1588c1736,1737
<           exception-definition ::=   exception constr-decl             
<                                  |  exception cconstr-name = cconstr   
<                                  |  exception ncconstr-name = ncconstr 
---
>   exception-definition ::=  exception constr-name  [of typexpr  { * typexpr }] 
>                         |   exception constr-name =  constr                    
1593,1595c1742,1744
<   The form exception constr-decl generates a new exception, distinct from all
< other exceptions in the system. The form exception name = constr gives an
< alternate name to an existing exception.  
---
>   The form exception constr-name  [of typexpr  { * typexpr }] generates a new
> exception, distinct from all other exceptions in the system. The form exception
> constr-name =  constr gives an alternate name to an existing exception.  
1611,1613c1760,1762
<          class-type ::=                                                      
<                       |  class-body-type                                     
<                       |  [[?]label]typexpr -> class-type                     
---
>         class-type ::=  class-body-type                                       
>                     |    [[?]label-name:]  typexpr ->  class-type             
>                                                                               
1616a1766
>                                                                               
1618c1768
<                       |  val [mutable] inst-var-name : typexpr               
---
>                     |    val [mutable] [virtual] inst-var-name :  typexpr     
1623a1774,1775
>   
> 
1628,1631c1780,1784
< class-path. Similarly, the expression [ typexpr_1 , ... typexpr_n ] class-path
< is equivalent to the parametric class type bound to the name class-path, in
< which type parameters have been instanciated to respectively typexpr_1,
< ...typexpr_n.
---
> class-path. Similarly, the expression [ typexpr_1 , ...  typexpr_n ] 
> class-path is equivalent to the parametric class type bound to the name
> class-path, in which type parameters have been instanciated to respectively
> typexpr_1, ...typexpr_n.
>   
1639a1793
> 
1655a1810
> 
1663a1819
> 
1668c1824
<   A specification of an instance variable is written val [mutable]
---
>   A specification of an instance variable is written val [mutable] [virtual]
1671c1827,1829
< instance variable can be physically modified.
---
> instance variable can be physically modified. The flag virtual indicates that
> this instance variable is not initialized. It can be initialized later through
> inheritance.
1674a1833
> 
1681,1687c1840,1846
< expected type, possibly polymorphic. The flag private indicates whether the
< method can be accessed from outside the class.
<   The polymorphism may be left implicit in method specifications: any type
< variable which is not bound to a class parameter and does not appear elsewhere
< inside the class specification will be assumed to be polymorphic, and made
< explicit in the resulting method type. Writing an explicit polymorphic type
< will disable this behaviour.
---
> expected type, possibly polymorphic. The flag private indicates that the method
> cannot be accessed from outside the object.
>   The polymorphism may be left implicit in public method specifications: any
> type variable which is not bound to a class parameter and does not appear
> elsewhere inside the class specification will be assumed to be universal, and
> made polymorphic in the resulting method type. Writing an explicit polymorphic
> type will disable this behaviour.
1690a1850
> 
1698a1859
> 
1715a1877
>                                          
1716a1879
>                                          
1717a1881
>                                          
1719,1726c1883,1891
<                                          [+]                                  
<                                          ---                                  
<                  |  class-expr {argument}[ ]                                  
<                                          ---                                  
<                                    [+]                                        
<                                    ---                                        
<                  |  fun {parameter}[ ] -> class-expr                          
<                                    ---                                        
---
>                                          
>                                           +                                    
>                                          
>                |    class-expr  {argument}                                     
>                                          
>                                    +                                           
>                                          
>                |    fun {parameter}  ->  class-expr                            
>                                          
1727a1893
>                                          
1728a1895,1897
>                                          
>                                                                                
>                                          
1729a1899
>                                          
1731c1901,1905
<                  |  method [private] method-name {pattern} [: typexpr] = expr 
---
>                                          
>                |    val [mutable] virtual inst-var-name :  typexpr             
>                                          
>                 |    method [private] method-name  {parameter}  [: typexpr] = 
>                                      expr 
1732a1907
>                                          
1733a1909
>                                          
1734a1911
>                                          
1737a1915,1918
>                                          
>   
>   
> 
1742,1744c1923,1926
< class-path. Similarly, the expression [ typexpr_1 , ... typexpr_n ] class-path
< evaluates to the parametric class bound to the name class-path, in which type
< parameters have been instanciated to respectively typexpr_1, ...typexpr_n.
---
> class-path. Similarly, the expression [ typexpr_1 , ...  typexpr_n ] 
> class-path evaluates to the parametric class bound to the name class-path, in
> which type parameters have been instanciated to respectively typexpr_1,
> ...typexpr_n.
1751a1934
> 
1757a1941
> 
1761,1764c1945,1948
<   The expression fun [[?]label]pattern -> class-expr evaluates to a function
< from values to classes. When this function is applied to a value v, this value
< is matched against the pattern pattern and the result is the result of the
< evaluation of class-expr in the extended environment.
---
>   The expression fun [[?]label-name:] pattern ->  class-expr evaluates to a
> function from values to classes. When this function is applied to a value v,
> this value is matched against the pattern pattern and the result is the result
> of the evaluation of class-expr in the extended environment.
1772a1957
> 
1778a1964
> 
1782,1784c1968,1971
<   The expression object ( pattern [: typexpr] ) { class-field } end denotes a
< class body. This is the prototype for an object : it lists the instance
< variables and methods of an objet of this class.
---
>           class-body ::=   [( pattern  [: typexpr] )]  { class-field } 
>    The expression object class-body end denotes a class body. This is the
> prototype for an object : it lists the instance variables and methods of an
> objet of this class.
1787,1789c1974,1976
<   In a class body, the pattern ( pattern [: typexpr] ) is matched against self,
< therefore provinding a binding for self and self type. Self can only be used in
< method and initializers.
---
>   In a class body, the pattern ( pattern  [: typexpr] ) is matched against
> self, therefore provinding a binding for self and self type. Self can only be
> used in method and initializers.
1792a1980
> 
1809a1998
> 
1815,1817c2004,2005
< inst-var-name whose initial value is the value of expression expr. Several
< variables of the same name can be defined in the same class. The flag mutable
< allows physical modification of this variable by methods.
---
> inst-var-name whose initial value is the value of expression expr. The flag
> mutable allows physical modification of this variable by methods.
1819a2008,2022
>   Since version 3.10, redefinitions of a visible instance variable with the
> same name do not create a new variable, but are merged, using the last value
> for initialization. They must have identical types and mutability. However, if
> an instance variable is hidden by omitting it from an interface, it will be
> kept distinct from other instance variables with the same name.
>   
> 
> Virtual instance variable definition
> ------------------------------------
>   
>     
>   Variable specification is written val [mutable] virtual inst-var-name : 
> typexpr. It specifies whether the variable is modifiable, and gives its type.
>   Virtual instance variables were added in version 3.10.
>   
1829,1832c2032,2035
< only be invoked on self (from other methods of the current class as well as of
< subclasses of the current class). This invocation is performed using the
< expression value-name # method-name, where value-name is directly bound to self
< at the beginning of the class definition. Private methods do not appear in
---
> only be invoked on self (from other methods of the same object, defined in this
> class or one of its subclasses). This invocation is performed using the
> expression value-name #  method-name, where value-name is directly bound to
> self at the beginning of the class definition. Private methods do not appear in
1848a2052
>   
1856a2061
> 
1865a2071
> 
1873a2080
> 
1889,1890c2096,2101
<      class-binding ::=   [virtual] [[ type-parameters ]] class-name  { pattern
<                         } [: class-type] = class-expr 
---
>                                                                                
>                                                        
>           class-binding ::=  [virtual] [[ type-parameters ]]  class-name 
>                   {parameter}  [: class-type]  =  class-expr 
>                                                                                
>                                                        
1893a2105,2106
>                                                        
>   
1903a2117
> 
1910a2125
> 
1926a2142,2143
>                                                                                
>                                           
1929a2147,2148
>                                           
>   
1940a2160,2161
>                                                                                
>                                              
1943a2165,2166
>                                              
>   
1970a2194,2201
>                                                                                
>                                              
>   mod-constraint ::=  type [type-parameters]  typeconstr =  typexpr            
>                                              
>                   |   module module-path =  extended-module-path               
>                                              
>                                                                                
>                                              
1995d2225
<   mod-constraint ::=   type [type-parameters] typeconstr = typexpr             
1997d2226
<                    |  module module-path = extended-module-path                
2022a2252
> 
2034a2265
> 
2043,2048c2274,2280
< typexp and an optional type representation  = constr-decl ... or = { label-decl
< ... }. The implementation of the type name in a matching structure must be
< compatible with the type expression specified in the equation (if given), and
< have the specified representation (if given). Conversely, users of that
< signature will be able to rely on the type equation or type representation, if
< given. More precisely, we have the following four situations:
---
> typexpr and an optional type representation  = constr-decl ... or = {
> field-decl ... }. The implementation of the type name in a matching structure
> must be compatible with the type expression specified in the equation (if
> given), and have the specified representation (if given). Conversely, users of
> that signature will be able to rely on the type equation or type
> representation, if given. More precisely, we have the following four
> situations:
2063,2065c2295,2297
<  Type abbreviation: an equation = typexp, no representation.
<  The type name must be implemented by a type compatible with typexp. All users
<    of the structure know that the type name is compatible with typexp.
---
>  Type abbreviation: an equation = typexpr, no representation.
>  The type name must be implemented by a type compatible with typexpr. All users
>    of the structure know that the type name is compatible with typexpr.
2078a2311
> 
2086a2320
> 
2095a2330
> 
2104a2340
> 
2115,2116c2351,2352
<    module module-name ( name_1 : module-type_1 )  ... ( name_n : module-type_n
<                                )  : module-type 
---
>          module module-name (  name_1 :  module-type_1 ) ... (  name_n : 
>                         module-type_n ) :  module-type 
2121a2358
> 
2169c2406
< a functor may take another functor as argument (``higher-order'' functor).
---
> a functor may take another functor as argument ("higher-order" functor).
2180,2181c2417,2418
< [type-parameters] typeconstr = typexp adds the type equation = typexp to the
< specification of the type component named typeconstr of the constrained
---
> [type-parameters]  typeconstr =  typexpr adds the type equation = typexpr to
> the specification of the type component named typeconstr of the constrained
2187,2188c2424
< <<
<           sig type t module M: (sig type u end) end
---
> <<        sig type t module M: (sig type u end) end
2191,2192c2427
< <<
<           sig type t=int module M: (sig type u end) end
---
> <<        sig type t=int module M: (sig type u end) end
2195,2196c2430
< <<
<           sig type t module M: (sig type u=N.u end) end
---
> <<        sig type t module M: (sig type u=N.u end) end
2200,2201c2434
< <<
<           functor (A: S) (B: S with type t = A.t) ...
---
> <<        functor (A: S) (B: S with type t = A.t) ...
2203a2437,2440
>   Constraints are added left to right. After each constraint has been applied,
> the resulting signature must be a subtype of the signature before the
> constraint was applied. Thus, the with operator can only add information on the
> type components of a signature, but never remove information.  
2225a2463,2464
>                                                                                
>                                                       
2239,2241c2478
<                                 module-type ] 
<                   = module-expr                                                
<                                              
---
>                         module-type ]  =  module-expr 
2281a2519
> 
2286,2288c2524,2526
<   A value definition let [rec] let-binding { and let-binding } bind value names
< in the same way as a let ... in ... expression (see section 6.7.1). The value
< names appearing in the left-hand sides of the bindings are bound to the
---
>   A value definition let [rec] let-binding  { and let-binding } bind value
> names in the same way as a let ... in ... expression (see section 6.7.1). The
> value names appearing in the left-hand sides of the bindings are bound to the
2294a2533
> 
2302a2542
> 
2309a2550
> 
2317a2559
> 
2326a2569
> 
2339,2340c2582,2583
<    module module-name ( name_1 : module-type_1 ) ...  ( name_n : module-type_n
<                                ) = module-expr 
---
>          module module-name (  name_1 :  module-type_1 ) ... (  name_n : 
>                         module-type_n ) =  module-expr 
2345a2589
> 
2353a2598
> 
2363a2609
> 
2371,2372c2617
< <<
<           struct type t = int  let x = 2 end
---
> <<        struct type t = int  let x = 2 end
2375,2376c2620
< <<
<           struct include S  let y = (x + 1 : t) end
---
> <<        struct include S  let y = (x + 1 : t) end
2379,2380c2623
< <<
<           struct type t = int  let x = 2  let y = (x + 1 : t) end
---
> <<        struct type t = int  let x = 2  let y = (x + 1 : t) end
2391a2635
> 
2396,2401c2640,2646
<   The expression functor ( module-name : module-type ) -> module-expr evaluates
< to a functor that takes as argument modules of the type module-type_1, binds
< module-name to these modules, evaluates module-expr in the extended
< environment, and returns the resulting modules as results. No restrictions are
< placed on the type of the functor argument; in particular, a functor may take
< another functor as argument (``higher-order'' functor).
---
>   The expression functor ( module-name :  module-type ) ->  module-expr
> evaluates to a functor that takes as argument modules of the type
> module-type_1, binds module-name to these modules, evaluates module-expr in the
> extended environment, and returns the resulting modules as results. No
> restrictions are placed on the type of the functor argument; in particular, a
> functor may take another functor as argument ("higher-order" functor).
>   
2417a2663
>                                                                  
2438c2684
<          name_1 : sig interface_1 end ...  name_n : sig interface_n end 
---
>     name_1 : sig  specification_1 end ...  name_n : sig  specification_n end 
2440,2441c2686,2687
< available in the search path (see chapter 8 for more details) and interface_1
< ... interface_n are their respective interfaces.   
---
> available in the search path (see chapter 8 for more details) and
> specification_1 ...  specification_n are their respective interfaces.

新規 編集 添付