[Nice-commit] Nice NEWS,1.42,1.43

[Daniel B. <bo...@us...>]

Update of /cvsroot/nice/Nice
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1474

Modified Files:
	NEWS 
Log Message:
Spell-checked past items.


Index: NEWS
===================================================================
RCS file: /cvsroot/nice/Nice/NEWS,v
retrieving revision 1.42
retrieving revision 1.43
diff -C2 -d -r1.42 -r1.43
*** NEWS	12 Aug 2004 23:21:43 -0000	1.42
--- NEWS	12 Aug 2004 23:43:21 -0000	1.43
***************
*** 3,18 ****
--- 3,24 ----
    * Assertions about the type of variables are used by the typechecker, so that
      casts are not necessary. For instance:
+ 
        Object o = ...;
        // We happen to know by design than the object must be a string
        assert o instanceof String;
        // Here o can be used as a string without cast
+ 
    * java.lang.Class is now parameterized by the type it represents.
      In particular, newInstance is now declared in nice.lang with
+ 
        <T> T newInstance(Class<T>);
+ 
      This make it possible to write type-safe code that uses reflexion,
      in particular when using class literals.
    * Subclasses can have less type parameters than their parent by fixing
      the value of the others. For instance:
+ 
        class BitField implements List<boolean> { ... }
+ 
    * Improved speed of coverage tests for some methods.
    * Removed the '--strict' compiler option.
***************
*** 47,51 ****
  nice (0.9.7)
  
!   * Methods can be overriden using the override keyword:
        class A {
          A doSomething() { ... }
--- 53,57 ----
  nice (0.9.7)
  
!   * Methods can be overridden using the override keyword:
        class A {
          A doSomething() { ... }
***************
*** 56,60 ****
      An important aspect is that the return type can be more precise than the
      original type (covariance).
!     Overriding without the override keyword (a la Java) is accepted but 
      generates a warning.
    * When importing a java package, it is possible to specify that its methods
--- 62,66 ----
      An important aspect is that the return type can be more precise than the
      original type (covariance).
!     Overriding without the override keyword (a la Java) is accepted but
      generates a warning.
    * When importing a java package, it is possible to specify that its methods
***************
*** 64,68 ****
    * The 'Any' keyword is now deprecated.
    * Global constants and global variables are now initialized in a proper order
!     when one depends on another, both directly and through the default 
      implementation of a method.
    * The Eclipse plugin now works with Eclipse 3.0 M7 (although 2.1 is still the
--- 70,74 ----
    * The 'Any' keyword is now deprecated.
    * Global constants and global variables are now initialized in a proper order
!     when one depends on another, both directly and through the default
      implementation of a method.
    * The Eclipse plugin now works with Eclipse 3.0 M7 (although 2.1 is still the
***************
*** 76,91 ****
        class Point { double x; double y; }
  
!       new Point(double angle, double distance) 
!       { 
          this(x: distance * cos(angle), y: distance * sin(angle));
        }
!     It is then possible to create a Point with either 
      new Point(x: ..., y: ...) or new Point(angle: ..., distance: ...).
!   * Additional fields can be defined for enums and enums can implement 
      interfaces, for instance:
        enum Coin(int value) implements Currency
  	{penny(1), nickel(5), dime(10), quarter(25)}
    * Alternative syntax for calling methods that takes an anonymous function
!     with no arguments. For example 'loop(5) { doSomeThing(); }' is a 
      shorthand for 'loop(5, () => { doSomeThing(); });'
    * "using" statement, as in C#, defined in nice.lang using (!) the above
--- 82,97 ----
        class Point { double x; double y; }
  
!       new Point(double angle, double distance)
!       {
          this(x: distance * cos(angle), y: distance * sin(angle));
        }
!     It is then possible to create a Point with either
      new Point(x: ..., y: ...) or new Point(angle: ..., distance: ...).
!   * Additional fields can be defined for enums and enums can implement
      interfaces, for instance:
        enum Coin(int value) implements Currency
  	{penny(1), nickel(5), dime(10), quarter(25)}
    * Alternative syntax for calling methods that takes an anonymous function
!     with no arguments. For example 'loop(5) { doSomeThing(); }' is a
      shorthand for 'loop(5, () => { doSomeThing(); });'
    * "using" statement, as in C#, defined in nice.lang using (!) the above
***************
*** 99,110 ****
    * Stricter parsing of expressions used as statements.
    * Improved performance for arrays used as lists.
!   * New methods (in package nice.functional) for working with iterators 
      and generators.
    * Applications that stop because of an uncaught exception will now
      print a stack trace the include correct Nice source files and line numbers.
      Applications that need to print a stack trace can do so by using
!     printStackTraceWithSourceInfo(e) (defined in nice.lang) instead of 
      e.printStackTrace(), and similarly for versions that specify a stream
!     or writer to print into.  
    * A super call can have types to resolve ambiguities. Example of usage:
        foo(BarSub b, s) = super(Bar, String);
--- 105,116 ----
    * Stricter parsing of expressions used as statements.
    * Improved performance for arrays used as lists.
!   * New methods (in package nice.functional) for working with iterators
      and generators.
    * Applications that stop because of an uncaught exception will now
      print a stack trace the include correct Nice source files and line numbers.
      Applications that need to print a stack trace can do so by using
!     printStackTraceWithSourceInfo(e) (defined in nice.lang) instead of
      e.printStackTrace(), and similarly for versions that specify a stream
!     or writer to print into.
    * A super call can have types to resolve ambiguities. Example of usage:
        foo(BarSub b, s) = super(Bar, String);
***************
*** 112,116 ****
      registration of the emacs mode for the SuSE Linux distribution.
    * Bug fixes (checking of local variables in a call position, make it possible
!     to use new Object() and dispatch on Object again, code generation of 
      integer constants, overloading of function symbols, printing of string
      literals with escaped chars, implicit 'this' for functional fields, ... )
--- 118,122 ----
      registration of the emacs mode for the SuSE Linux distribution.
    * Bug fixes (checking of local variables in a call position, make it possible
!     to use new Object() and dispatch on Object again, code generation of
      integer constants, overloading of function symbols, printing of string
      literals with escaped chars, implicit 'this' for functional fields, ... )
***************
*** 128,132 ****
        }
      This syntax should be more consistent and familiar, and is now
!     prefered to the old one, which will eventually be deprecated.
    * Object is now recognized as a super-type of every type. This allows
      easier use of Java libraries, creation of heterogeneous collections,
--- 134,138 ----
        }
      This syntax should be more consistent and familiar, and is now
!     preferred to the old one, which will eventually be deprecated.
    * Object is now recognized as a super-type of every type. This allows
      easier use of Java libraries, creation of heterogeneous collections,
***************
*** 149,154 ****
    * Unused local variables will give a warning.
    * Nested multi-line comments are allowed.
!   * Empty statements (made of a single ';') have been removed. This avoids the 
!     risk of an accidental ';' changing the meaning of a statement. Empty 
      statements are very rarely needed, and can easily be replaced by '{}'.
    * The Emacs mode is updated to work with recent versions of GNU and XEmacs.
--- 155,160 ----
    * Unused local variables will give a warning.
    * Nested multi-line comments are allowed.
!   * Empty statements (made of a single ';') have been removed. This avoids the
!     risk of an accidental ';' changing the meaning of a statement. Empty
      statements are very rarely needed, and can easily be replaced by '{}'.
    * The Emacs mode is updated to work with recent versions of GNU and XEmacs.
***************
*** 158,164 ****
      only if they are actually used. This reduces memory usage and improves
      compilation speed.
!   * Bug fixes (accessing static fields of an superclass or interface, 
!     compilation of polymorphic tuples, captured 'this' in initializer, 
!     duplication of constructors in bytecode, disappearing contracts during 
      recompilation, ... )
  
--- 164,170 ----
      only if they are actually used. This reduces memory usage and improves
      compilation speed.
!   * Bug fixes (accessing static fields of an superclass or interface,
!     compilation of polymorphic tuples, captured 'this' in initializer,
!     duplication of constructors in bytecode, disappearing contracts during
      recompilation, ... )
  
***************
*** 167,176 ****
  nice (0.9.4)
  
!   * The compiler now knows that the statement 'assert false' never terminates. 
!     Therefore that statement can be used in a branch that is known to be 
      unused, without needing to return a dummy value when the method does not
      return void.
    * Added source-level debugging information for recent debuggers (jsr 45).
!   * Constraints on class type parameters can be written as a prefix of 
      class declarations:
        <Bound T> class MyClass<T> { ... }
--- 173,182 ----
  nice (0.9.4)
  
!   * The compiler now knows that the statement 'assert false' never terminates.
!     Therefore that statement can be used in a branch that is known to be
      unused, without needing to return a dummy value when the method does not
      return void.
    * Added source-level debugging information for recent debuggers (jsr 45).
!   * Constraints on class type parameters can be written as a prefix of
      class declarations:
        <Bound T> class MyClass<T> { ... }
***************
*** 193,197 ****
    * Existing interfaces can (like classes) implement abstract interfaces:
        interface packagename.SomeInterface implements AbstractInterface;
!   * Bugfixes (various pretty printing issues, type hole in instanceof 
      inference, calls to abstract methods, chained assignments with arrays like
      'x = arr[y] = z;', error messages of integer dispatch, reachability of
--- 199,203 ----
    * Existing interfaces can (like classes) implement abstract interfaces:
        interface packagename.SomeInterface implements AbstractInterface;
!   * Bugfixes (various pretty printing issues, type hole in instanceof
      inference, calls to abstract methods, chained assignments with arrays like
      'x = arr[y] = z;', error messages of integer dispatch, reachability of
***************
*** 205,209 ****
      flexible.
      The syntax that used to define a function is still valid: it now
!     declares a method together with a default implementation. Exemple:
        class A {
          // Declares a method f, with a default implementation that returns 1.
--- 211,215 ----
      flexible.
      The syntax that used to define a function is still valid: it now
!     declares a method together with a default implementation. Example:
        class A {
          // Declares a method f, with a default implementation that returns 1.
***************
*** 217,230 ****
        }
      The same applies for methods outside classes.
!   * More dynamic type inference implemented. The type of a local variable is 
!     made more precise after a succesful instanceof:
      A a = ...;
      if (a instanceof B)
        // Here a has type B
!   * Classes that implement java.lang.Cloneable now automatically support 
      the clone method.
    * The deprecated 'main(args) { ... }' syntax for the main function is not
      supported anymore. Please use instead: 'void main(String[] args) { ... }'
!   * Floating point literals are now of type double by default, adding 
      'f' or 'F' at the end will make them of type float.
    * Method parameters that are not dispatched on simply get their declared
--- 223,236 ----
        }
      The same applies for methods outside classes.
!   * More dynamic type inference implemented. The type of a local variable is
!     made more precise after a successful instanceof:
      A a = ...;
      if (a instanceof B)
        // Here a has type B
!   * Classes that implement java.lang.Cloneable now automatically support
      the clone method.
    * The deprecated 'main(args) { ... }' syntax for the main function is not
      supported anymore. Please use instead: 'void main(String[] args) { ... }'
!   * Floating point literals are now of type double by default, adding
      'f' or 'F' at the end will make them of type float.
    * Method parameters that are not dispatched on simply get their declared
***************
*** 235,239 ****
        for (i : 1..10) println(i);
    * In local variable declarations like 'var x = exp', the inferred type
!     for x is int when 'exp' is of type byte or short. This will avoid 
      unexpected behaviour in some cases.
    * Bugfixes (incrementation of byte local variables, require a default value
--- 241,245 ----
        for (i : 1..10) println(i);
    * In local variable declarations like 'var x = exp', the inferred type
!     for x is int when 'exp' is of type byte or short. This will avoid
      unexpected behaviour in some cases.
    * Bugfixes (incrementation of byte local variables, require a default value
***************
*** 244,251 ****
  nice (0.9.1)
  
!   * Final fields can be overriden in sub-classes with a more precise type
!     and a different default value. In particular, this removes the need for 
      a cast when reading the field's value from an instance of the sub-class.
!       class A 
        {
          final List<String> names;
--- 250,257 ----
  nice (0.9.1)
  
!   * Final fields can be overridden in sub-classes with a more precise type
!     and a different default value. In particular, this removes the need for
      a cast when reading the field's value from an instance of the sub-class.
!       class A
        {
          final List<String> names;
***************
*** 258,265 ****
    * A class can now have initializers, which are executed each time an instance
      is created.
!       class A 
        {
          // Initializer
!         { 
            // Initialization code goes here.
          }
--- 264,271 ----
    * A class can now have initializers, which are executed each time an instance
      is created.
!       class A
        {
          // Initializer
!         {
            // Initialization code goes here.
          }
***************
*** 272,276 ****
        for (elem : array) println(elem);
    * The compiler now warns about non-existing sourcepath entries.
!   * Bugfixes (parameter's default value refering to previous parameters, ...)
  
   -- Sat,  9 Aug 2003 23:19:41 +0200
--- 278,282 ----
        for (elem : array) println(elem);
    * The compiler now warns about non-existing sourcepath entries.
!   * Bugfixes (parameter's default value referring to previous parameters, ...)
  
   -- Sat,  9 Aug 2003 23:19:41 +0200
***************
*** 319,334 ****
        foo(number) { ... } //correct
        //foo(num) { ... } //not valid
!     This is important, so that a typo in a global constant or enum name 
      in a method implementation does not lead to a default implementation.
    * Added operator ** to calculate powers of longs, doubles and BigIntegers.
!   * The 'char' type is no longer a subtype of int. The integer unicode 
      representation of a character c can be obtained by int(c).
    * Interfaces can now implement (finally or not) abstract interfaces.
    * 'true' and 'false' are now keywords, and better code is generated for them.
!     The termination properties of loops with literal boolean values are now 
      recognized, as in Java.
    * Redefining of local variables in their scope is not allowed anymore.
    * Method bodies with a single statement can be written without brackets.
!     example: void foo() = throw new Exception(); 
    * It is possible to bind the values of tuple arguments to functions:
        String foo((String s, String t)) = s + t;
--- 325,340 ----
        foo(number) { ... } //correct
        //foo(num) { ... } //not valid
!     This is important, so that a typo in a global constant or enum name
      in a method implementation does not lead to a default implementation.
    * Added operator ** to calculate powers of longs, doubles and BigIntegers.
!   * The 'char' type is no longer a subtype of int. The integer unicode
      representation of a character c can be obtained by int(c).
    * Interfaces can now implement (finally or not) abstract interfaces.
    * 'true' and 'false' are now keywords, and better code is generated for them.
!     The termination properties of loops with literal boolean values are now
      recognized, as in Java.
    * Redefining of local variables in their scope is not allowed anymore.
    * Method bodies with a single statement can be written without brackets.
!     example: void foo() = throw new Exception();
    * It is possible to bind the values of tuple arguments to functions:
        String foo((String s, String t)) = s + t;
***************
*** 348,352 ****
      overloading resolution of method implementations with additional tc's, ...)
    * Improved some error messages.
!   
   -- Fri, 18 Jul 2003 01:40:25 +0200
  
--- 354,358 ----
      overloading resolution of method implementations with additional tc's, ...)
    * Improved some error messages.
! 
   -- Fri, 18 Jul 2003 01:40:25 +0200
  
***************
*** 356,360 ****
    * Added operators to compute with java.math.BigInteger (+,-,*,/,%,...).
    * In functional types, '()' is always equivalent to 'void'. Ex: int->()
!   * Anonymous functions that never return normally can be used with any 
      return type.
    * Bugfixes (some cases of optional parameters, allowing arbitrarily nested
--- 362,366 ----
    * Added operators to compute with java.math.BigInteger (+,-,*,/,%,...).
    * In functional types, '()' is always equivalent to 'void'. Ex: int->()
!   * Anonymous functions that never return normally can be used with any
      return type.
    * Bugfixes (some cases of optional parameters, allowing arbitrarily nested
***************
*** 363,367 ****
      is declared inside a class, declaration of multiple local variables,
      nested type parameters in method declarations, improved some error messages,
!     resolving overloading between fields and global variables, implemented 
      nullness inference for local constants).
  
--- 369,373 ----
      is declared inside a class, declaration of multiple local variables,
      nested type parameters in method declarations, improved some error messages,
!     resolving overloading between fields and global variables, implemented
      nullness inference for local constants).
  
***************
*** 391,395 ****
          // Now we use the fact the res is a list.
          // Therefore, it would be impossible to declare its type as C<U>.
!         res.add(res[0]); 
  
          // By returning res, we need the fact that it is a subtype of C<U>,
--- 397,401 ----
          // Now we use the fact the res is a list.
          // Therefore, it would be impossible to declare its type as C<U>.
!         res.add(res[0]);
  
          // By returning res, we need the fact that it is a subtype of C<U>,
***************
*** 397,407 ****
          return res;
        }
!   * Changed the syntax for local variables. The "final" keyword is deprecated 
!     now for local variables, use "let" instead. In addition to the standard 
      "type name = ..." syntax two new forms are allowed:
!     let [ type ] name [ = expression ] ; 
      var [ type ] name [ = expression ] ;
      At least a type or a default value are required.
!     The type can only be left away when the compiler is able to interfere 
      the type which is not always possible.
      A non function example to show some aspects the new syntax:
--- 403,413 ----
          return res;
        }
!   * Changed the syntax for local variables. The "final" keyword is deprecated
!     now for local variables, use "let" instead. In addition to the standard
      "type name = ..." syntax two new forms are allowed:
!     let [ type ] name [ = expression ] ;
      var [ type ] name [ = expression ] ;
      At least a type or a default value are required.
!     The type can only be left away when the compiler is able to interfere
      the type which is not always possible.
      A non function example to show some aspects the new syntax:
***************
*** 431,436 ****
  nice (0.7.8)
  
!   * Some error messages are more usefull.
!   * All operators are inlined and some operators (&&, ||, ! and comparisons) 
      and if-statements generate better bytecode now.
    * Improved bytecode generation of pre/post-condition.
--- 437,442 ----
  nice (0.7.8)
  
!   * Some error messages are more useful.
!   * All operators are inlined and some operators (&&, ||, ! and comparisons)
      and if-statements generate better bytecode now.
    * Improved bytecode generation of pre/post-condition.
***************
*** 450,454 ****
    * Allow nested tuples on the left side of a tuple assignment:
        (String a, (String b, String c)) = ("a", ("b", "c"));
!   * Bugfixes (solved problems with case insentive filenames, ...).
  
   -- Tue,  8 Apr 2003 21:03:43 +0200
--- 456,460 ----
    * Allow nested tuples on the left side of a tuple assignment:
        (String a, (String b, String c)) = ("a", ("b", "c"));
!   * Bugfixes (solved problems with case-insensitive filenames, ...).
  
   -- Tue,  8 Apr 2003 21:03:43 +0200
***************
*** 474,485 ****
    * The 'fun' keyword for anonymous functions is deprecated. It can be omitted.
    * New policy for typing calls to Java methods. By default, the typing
!     is more convenient, considering arguments as possibly null, and 
      results as non-null. The '--strict' compiler option enforces a stricter
      heuristic.
!     Additionally, arrays are always considered to have non-null component 
      types.
      Final fields are considered non-null.
    * Static native methods are not (wrongly) imported in the global name space
!     anymore. One can just use them as in Java, by prefixing with the class 
      name:
        String s = Integer.toHexString(100);
--- 480,491 ----
    * The 'fun' keyword for anonymous functions is deprecated. It can be omitted.
    * New policy for typing calls to Java methods. By default, the typing
!     is more convenient, considering arguments as possibly null, and
      results as non-null. The '--strict' compiler option enforces a stricter
      heuristic.
!     Additionally, arrays are always considered to have non-null component
      types.
      Final fields are considered non-null.
    * Static native methods are not (wrongly) imported in the global name space
!     anymore. One can just use them as in Java, by prefixing with the class
      name:
        String s = Integer.toHexString(100);
***************
*** 490,494 ****
    * Added the 'concat' function on arrays, and sort function for lists.
    * Faster compilation for large projects with many classes.
!   * Bugfixes (anonymous functions inside functionals with constracts,
      typechecking loop tests, other fixes to reduce the difference between
      what the parser accepts and the compiler can handle, ...).
--- 496,500 ----
    * Added the 'concat' function on arrays, and sort function for lists.
    * Faster compilation for large projects with many classes.
!   * Bugfixes (anonymous functions inside functionals with contracts,
      typechecking loop tests, other fixes to reduce the difference between
      what the parser accepts and the compiler can handle, ...).
***************
*** 498,502 ****
  nice (0.7.6)
  
!   * Implemented optional parameters' default value refering to 
      previous parameters, like 'to' in the following example:
        <T> T[] slice(T[] array, int from = 0, int to = array.length - 1);
--- 504,508 ----
  nice (0.7.6)
  
!   * Implemented optional parameters' default value referring to
      previous parameters, like 'to' in the following example:
        <T> T[] slice(T[] array, int from = 0, int to = array.length - 1);
***************
*** 504,508 ****
        if (0 < i < N) ...
    * Fixed several issues with generic collections.
!     In particular, for List<int> there was an ambiguity between 
        remove(int) and remove(T) (since T=int).
      Therefore we renamed remove(int) into removeAt(int).
--- 510,514 ----
        if (0 < i < N) ...
    * Fixed several issues with generic collections.
!     In particular, for List<int> there was an ambiguity between
        remove(int) and remove(T) (since T=int).
      Therefore we renamed remove(int) into removeAt(int).
***************
*** 516,526 ****
      declared externally to a class.
    * Parser support for public-read and private-write fields (experimental).
!   * Performance improvement for anonymous functions and for polymorphic 
      usage of arrays.
    * Improved references to source lines in the bytecode (stack traces).
!   * Bugfixes (using anonymous functions while overriding native methods, 
!     automatic array conversions in polymorphic code, nested literal primitive 
!     arrays, mutually dependant packages, ...).
!   * For convenience of command-line tools (shells) with automatic completion, 
      we allow a directory name instead of the corresponding package name.
      That is, we replace '/' (which is illegal in package names) by '.'.
--- 522,532 ----
      declared externally to a class.
    * Parser support for public-read and private-write fields (experimental).
!   * Performance improvement for anonymous functions and for polymorphic
      usage of arrays.
    * Improved references to source lines in the bytecode (stack traces).
!   * Bugfixes (using anonymous functions while overriding native methods,
!     automatic array conversions in polymorphic code, nested literal primitive
!     arrays, mutually dependent packages, ...).
!   * For convenience of command-line tools (shells) with automatic completion,
      we allow a directory name instead of the corresponding package name.
      That is, we replace '/' (which is illegal in package names) by '.'.
***************
*** 537,541 ****
    * Addition of the || operator on optional values:
        e1 || e2
!     evalues e1 and returns its value if it is not null (without evaluating e2).
      If e1 evaluates to null it returns the value of e2.
      It is equivalent to e1 != null ? e1 : e2, except e1 is not evaluated twice.
--- 543,547 ----
    * Addition of the || operator on optional values:
        e1 || e2
!     evaluates e1 and returns its value without evaluating e2 if e1 is not null.
      If e1 evaluates to null it returns the value of e2.
      It is equivalent to e1 != null ? e1 : e2, except e1 is not evaluated twice.
***************
*** 546,550 ****
    * Short anonymous functions made of one assignment now return void. Allows:
        [1,2,3].foreach(int j => i += j);
!     instead of 
        [1,2,3].foreach(int j => { i += j; });
    * Arrays created with 0 elements have a non-option component type:
--- 552,556 ----
    * Short anonymous functions made of one assignment now return void. Allows:
        [1,2,3].foreach(int j => i += j);
!     instead of
        [1,2,3].foreach(int j => { i += j; });
    * Arrays created with 0 elements have a non-option component type:
***************
*** 553,557 ****
      They can still be used with option component type:
        ?String[] s0 = new String[0];
!   * Changed suffix notation for multiple-dimension array types, to match 
      initialization. Dimensions are listed in order, instead of reverse order.
      For instance,
--- 559,563 ----
      They can still be used with option component type:
        ?String[] s0 = new String[0];
!   * Changed suffix notation for multiple-dimension array types, to match
      initialization. Dimensions are listed in order, instead of reverse order.
      For instance,
***************
*** 572,576 ****
  nice (0.7.4)
  
!   * Added support for Generic Java types. This allows in particular to use 
      java.util.* collections with parameterized types (e.g. List<String>).
      These replace the previous (very partial) collections from nice.lang.
--- 578,582 ----
  nice (0.7.4)
  
!   * Added support for Generic Java types. This allows in particular to use
      java.util.* collections with parameterized types (e.g. List<String>).
      These replace the previous (very partial) collections from nice.lang.
***************
*** 584,588 ****
      class, and when a class or interface (indirectly) implements itself.
    * Allow the <T> syntax to introduce type variables, in addition to
!     <Any T> (that is, any is optional). This is consistent with GJ, 
      and the syntax for class type parameters.
    * Improved overloading resolution when used on functions with optional
--- 590,594 ----
      class, and when a class or interface (indirectly) implements itself.
    * Allow the <T> syntax to introduce type variables, in addition to
!     <Any T> (that is, any is optional). This is consistent with GJ,
      and the syntax for class type parameters.
    * Improved overloading resolution when used on functions with optional
***************
*** 652,658 ****
    * Added the ".class" construct.
    * Completed the "instanceof" construct.
!   * Calling new T[size] where T is a type variable now correctly returns 
      an array with optional element type. It can be filled with non-null values
!     using the 'fill' function, e.g. 
          fill(new T[size], int i => f(x[i]))
  
--- 658,664 ----
    * Added the ".class" construct.
    * Completed the "instanceof" construct.
!   * Calling new T[size] where T is a type variable now correctly returns
      an array with optional element type. It can be filled with non-null values
!     using the 'fill' function, e.g.
          fill(new T[size], int i => f(x[i]))
  
***************
*** 665,670 ****
    * The compiler is now reentrant. This should not make any difference
      when running from the command-line, but this is important to allow
!     tools written in Java or Nice (like the Ant task, the testsuite, 
!     an IDE) to call the compiler repetively, without starting a new JVM.
    * Fixed several bugs (export of optional functional types, ...).
  
--- 671,676 ----
    * The compiler is now reentrant. This should not make any difference
      when running from the command-line, but this is important to allow
!     tools written in Java or Nice (like the Ant task, the testsuite,
!     an IDE) to call the compiler repetitively, without starting a new JVM.
    * Fixed several bugs (export of optional functional types, ...).
  
***************
*** 676,688 ****
        int i => i+1          /* function of one argument */
        (int i, int j) => i+j /* function of several arguments */
!   * Renamed `iter` to `foreach`. `iter` is still accepted, 
      but will probably be removed sometime in the future.
      Together with the syntax change for anonymous functions,
      this gives a nice and user-friendly syntax for iterations:
!     
        names.foreach(String name => println(name));
  
!   * Anonymous function cannot appear where a statement is expected 
!     (some expressions can). This is good since an anonymous function which 
      is not called cannot have side-effects, and therefore this case was
      meaningless and probably buggy.
--- 682,694 ----
        int i => i+1          /* function of one argument */
        (int i, int j) => i+j /* function of several arguments */
!   * Renamed `iter` to `foreach`. `iter` is still accepted,
      but will probably be removed sometime in the future.
      Together with the syntax change for anonymous functions,
      this gives a nice and user-friendly syntax for iterations:
! 
        names.foreach(String name => println(name));
  
!   * Anonymous function cannot appear where a statement is expected
!     (some expressions can). This is good since an anonymous function which
      is not called cannot have side-effects, and therefore this case was
      meaningless and probably buggy.
***************
*** 694,705 ****
  nice (0.5.3)
  
!   * Testing a variable against null in a while or for loop condition now 
      allows to use it as non-null, until is it assigned a possibly null value.
!   * Added many mathematical functions (sin, cos, round, max, min, ...). 
      This makes it unnecessary to prefix them with (java.lang.)Math.
!   * It is now possible to use "." (current directory) in 
!     the --classpath argument (this needed a workaround for 
      a probable bug in Sun's URLClassLoader, at least in 1.3).
!   * Other bugfixes (creating arrays of "exotic" types, using arrays in field 
      initializers).
  
--- 700,711 ----
  nice (0.5.3)
  
!   * Testing a variable against null in a while or for loop condition now
      allows to use it as non-null, until is it assigned a possibly null value.
!   * Added many mathematical functions (sin, cos, round, max, min, ...).
      This makes it unnecessary to prefix them with (java.lang.)Math.
!   * It is now possible to use "." (current directory) in
!     the --classpath argument (this needed a workaround for
      a probable bug in Sun's URLClassLoader, at least in 1.3).
!   * Other bugfixes (creating arrays of "exotic" types, using arrays in field
      initializers).
  
***************
*** 723,729 ****
    * Constructors now take the initial values of the object's fields as
      named arguments. A field declaration (inside a class declaration)
!     now accepts an optional value after "=" (like in Java). This value 
!     is used as the default if the field is not mentioned in a call to 
!     the constructor. A field with no default value must be mentioned 
      in every call to the constructor.
    * Compile properly functions declared inside abstract interfaces.
--- 729,735 ----
    * Constructors now take the initial values of the object's fields as
      named arguments. A field declaration (inside a class declaration)
!     now accepts an optional value after "=" (like in Java). This value
!     is used as the default if the field is not mentioned in a call to
!     the constructor. A field with no default value must be mentioned
      in every call to the constructor.
    * Compile properly functions declared inside abstract interfaces.
***************
*** 740,750 ****
    * Assigning a possibly null value to a variable of non-null type
      now produces an error instead of a warning.
!   * Fixes bug that considered that 
        int a = 10, b;
      initializes both a and b to 10.
    * Fixed variable initialization analysis for do-while loops.
    * Make the compiler compatible with JDK 1.4
!   * Fixed bug on MS-Windows with archive creation because of the 
!     case-insensivity of the file system.
    * Fixed creation of archive from up-to-date packages stored in jar.
    * Accept anonymous functions that do nothing.
--- 746,756 ----
    * Assigning a possibly null value to a variable of non-null type
      now produces an error instead of a warning.
!   * Fixes bug that considered that
        int a = 10, b;
      initializes both a and b to 10.
    * Fixed variable initialization analysis for do-while loops.
    * Make the compiler compatible with JDK 1.4
!   * Fixed bug on MS-Windows with archive creation because of the
!     case-insensitivity of the file system.
    * Fixed creation of archive from up-to-date packages stored in jar.
    * Accept anonymous functions that do nothing.
***************
*** 770,774 ****
    * Arrays of void values are forbidden. They most probably originate from
      a bug in the source program.
!   * Better handling of inhomogenous tuples with native types (e.g. <int, long>)
    * Better wrapping/unwrapping code for arrays used as Collections.
    * Bugfixes for some polymorphic operations on arrays.
--- 776,781 ----
    * Arrays of void values are forbidden. They most probably originate from
      a bug in the source program.
!   * Better handling of inhomogeneous tuples with native types
!     (e.g. <int, long>).
    * Better wrapping/unwrapping code for arrays used as Collections.
    * Bugfixes for some polymorphic operations on arrays.
***************
*** 779,786 ****
  nice (0.0.020226)
  
!   * Fixed bug that prevented using "this" in overriden native methods.
    * Better error messages for method calls with wrong number of arguments.
    * Accept methods with no implementation when their domain is empty.
!   * Abstract interfaces are fully qualified just like classes and 
      correctly list their super-interfaces in the package interface.
      This really makes it possible to use them across packages.
--- 786,793 ----
  nice (0.0.020226)
  
!   * Fixed bug that prevented using "this" in overridden native methods.
    * Better error messages for method calls with wrong number of arguments.
    * Accept methods with no implementation when their domain is empty.
!   * Abstract interfaces are fully qualified just like classes and
      correctly list their super-interfaces in the package interface.
      This really makes it possible to use them across packages.
***************
*** 797,803 ****
    * Added 'break' and 'continue' statements.
    * Implemented 'do' loops.
!   * Allow overriding of native java methods. It is now possible to 
      define a subclass of a java class or interface and override the methods.
!   * Changed compilation scheme for method alternatives. This results in 
      shorter class files and more intuitive stack traces.
  
--- 804,810 ----
    * Added 'break' and 'continue' statements.
    * Implemented 'do' loops.
!   * Allow overriding of native java methods. It is now possible to
      define a subclass of a java class or interface and override the methods.
!   * Changed compilation scheme for method alternatives. This results in
      shorter class files and more intuitive stack traces.
  
***************
*** 817,822 ****
    * Added the 'instanceof' and '~' (bitwise complement) keywords.
    * Do not stop at the first syntax or type error in more situations.
!   * Ehanced error messages.
!   * Emacs mode: allow to interactively set the compiler's location 
      (the string variable 'nice-program').
  
--- 824,829 ----
    * Added the 'instanceof' and '~' (bitwise complement) keywords.
    * Do not stop at the first syntax or type error in more situations.
!   * Enhanced error messages.
!   * Emacs mode: allow to interactively set the compiler's location
      (the string variable 'nice-program').