0.9.3, May 15 2006
  We now require mono 1.1.13 or newer (or MS.NET 2.0 as usual).
 
    * Limited support for Nullable type:
      * using nullable syntax (int?, MyStruct?), 
      * autoconversion of null and values to Nullable[T] (null : double?, 66 : int?)
      * == and != operator with null literal (x == null, y != null)
      (using operators on two nullable instances doesn't work yet)
    * Extension methods (MORE)
    * using (def x = ...) now works.
    * Fixes in casts involving generic types.
    * We do not consider void subtype of object anymore. We also do not
      allow void to be type parameter of generic types. This seems
      to have caused more trouble than it's worth.
    * Better message for errors in calls.
    * Updates of Nemerle Emacs mode.
    * Arrays are now considered subtypes of IEnumerable and the like.
    * One can now say class A[T] where T : enum.
    * Types can be nested in variants now.
    * Default stack size on MS.NET should not cause problems (with Out 
      of memoery exn) now.
    * '(x, y) => expr' can be used in place of fun (x, y) { expr }.  
    

  Library changes:
    * Optimizations in RList.
    * Value/HasValue in option.
    * Heap and Set now implement ICollection[T].
    * Methods from NArray and NString are now extension methods.

  Macro library changes:
    * Record macro can now be forced to exclude/include fields.

  Backward incompatible library changes:
    * The NC.Hashtable indexer was changed to follow SCG.Dictionary behavior
      of throwing exception when the key is not found.

  Fixed issues from BTS:
    * #338: Caching in ++x macro do not play nice with valuetypes
    * #416: allow extending existing classes
    * #503: Cannot do type match on 'a
    * #547: generic constraint 'a : 'b and static instance problem
    * #575: Tail calls optimization causes invalid IL to be generated
    * #588: Nullrefence in runtime for yields in try block
    * #589: ICE in Typer for locked yield
    * #590: ICE in Check STV for generic delegates
    * #591: Typer ICE for type check involving generic type
    * #594: bogus "ambiguous type" message
    * #595: too rigid protected member checking in nested types
    * #598: LookupInternalType does not check the supported size of Function 
            object
    * #604: compile error(mono svn 56155 and nemele svn 6088)
    * #605: Casts from value type to 'a causes invalid IL
    * #606: possible problem with loop closures
    * #607: typo in sqlmacro
    * #608: lazy literals
    * #609: System.Bool instead of System.Boolean
    * #612: code generation problem with uint
    * #613: Ncc crushes during the compilation process
    * #614: Record to generate constructor just for not initialized fields
    * #617: optional regexp match
    * #618: -0 causes compilation error
    * #620: MainParser.ParseExpr("def f(){}") and MainParser.ParseExpr("")
            cause NullReferenceException
    * #621: SomeFunction(throw Exception()) produces invalid IL
    * #622: ICE for polymorphic property used in matching
    * #623: probably more array tweaks required 
    * #624: Internal compiler error for $ outside quotations
    * #625: strange error when misusing macro-generated type
    * #626: Quoted declaration of method override results in compile-time
            error
    * #627: Increment in argument
    * #628: Ugly error message (for list[void])
    * #630: Implicit conversions doesn't work for generic parameter
    * #631: Patch for quoted declarations to support ellipsis in
            class/interface members declaration
    * #636: lock (expr) will evaluate expr twice
    * #637: Compiler skips some classes during compilation
    * #639: A compile-time calculus and code generation
    * #641: Compiler crash due to function to delegate conversion inside
            generic class
    * #642: Error if list declared without initialisation
    * #644: Wrong behavior during base ctor call
    * #645: Nemerle.DesignPatterns.ProxyPublicMembers error
    * #647: problems with preprocessor and the $ macro
    * #648: Wrong error message when interface implementation is not complete
    * #649: Can't provide generic constraint in quoted declaration
    * #650: Attribute compilation error.
    * #652: Generic parameter names can't be used inside quoted declaration
    * #653: Empty interface can't be defined from macro
    * #654: Makefile, install target
    * #656: Assembly attribute don't gets added from assembly-level 
            macro-attribute
    * #657: Unhandled Exception: Nemerle.Core.MatchFailureException in ncc
    * #658: Trying to parameterize non-generic type shows up a lot of vagu
            error messages
    * #661: extension method can not find member.
    * #662: C#3.0 like lambda expression operator priority
    * #663: ASP.NET functionality broken on Windows platform
    * #666: Can't build sources from latest snapshot (r6245)
    * #667: "make install" doesn't install Nemerle assemblies into GAC
    * #668: msbuild cannot build Nemerle.sln
    * #669: Cannot install a snapshot
    * #670: Can't set the value of byte array element with index not 
            divisible by 4 without explicit cast.
    * #671: Problem with resources included into assembly
    * #672: Compiler reports non-existence of a namespace, althougth it
            exists.
    * #674: type inference cannot guess.
    * #675: ExtensionAttribute's namespace on System.Query.dll.


0.9.2, Jan 21 2006
  This version brings a bunch of new features and of course several bugfixes.
  We now require mono 1.1.11+ or MS.NET 2.0.

  New language features:
    * Generators aka yield support: http://nemerle.org/Yield
    * List comprehensions + ranges: http://nemerle.org/List_comprehensions
    * Extensible pattern matching: http://nemerle.org/Extensible_matching
    * 'this' can be now used as the full type (including type parameters)
      of the current class.
    * Matching directly in function parameters, it is now possible to say:
        def foo (x, (y, z)) { ... }
	def bar ((a, b), (c, d, e)) { ... }

  Macros:
    * New package of profiling macros: http://nemerle.org/Profiling_macros
    * Extensions in logging macros: http://nemerle.org/Logging_macros
    * Nemerle.DesignPatterns.ProxyPublicMembers macro has been added: http://nemerle.org/Design_patterns#Macro_included_in_standard_library

  Library:
    * New RList module (Random Access Lists as described by Chris Okasaki),
      by Wojtek Knapik.

  Other:
    * -main flag in ncc for specifying entry point.
    * Kinda hackish support for ASPX/ASMX in cs2n.
    * NoiseEHC contributed a fix to MSBuild task, which is necessary for VS plugin development

  Bugfixes:
    * Always use at least 16M of stack when compiling on MS.NET (should
      fix stack overflow errors).
    * Fix foreach on multidimensional arrays.
    * XSP2 fixes by Kanru Chen.

  And from mantis:
    * #593: we don't save mutable attribute for fields
    * #587: Generator Enumerable is incorrectly created
    * #518: matching directly function parameters
    * #529: Support for generators
    * #584: Compiler crash when using an array initialiser with mixed
            types of initialiser elements and no explicit array rank.
    * #582: Compiling "a.b.c.d.e" crashes compiler
    * #583: Compiler crash with mixture of constructor chaining and inheritance.
    * #581: problems with closure constructions
    * #576: nemerle-0.9.1.99.5974: internal compiler error
    * #571: Cast is treated as type enforcement in delayed typing
    * #555: indexers are not delayed
    * #574: Internal compiler error
    * #565: No newline at the and of file causes error
    * #568: add -stack:10M kind of option to increase the stack while
            running the compiler
    * #536: assertion in Typer3 for generic local method
    * #561: Compiler internal error when defining nested generic tree
    * #527: nested type lookup with generic inheritance
    * #563: Generic parameters are not correctly inherited in nested
            type of nested type of generic type
    * #556: function types cannot be treated as objects
    * #566: problem with _ is <[ _ ]>
    * #567: unregistered value with 'with' matching


0.9.1, Nov 4 2005
  This release brings the long-awaited indentation syntax and a few 
  bugfixes.

  About 150 SVN commits were made since the last release.

  Language changes:
    * With the -i option compiler can now recognize indentation based syntax.
      More info at http://nemerle.org/Indentation-based_syntax

  Additions:
    * MSBuild task.
    * Marcin Grzeskowiak contributed a new matching compiler as a part
      of his MSc thesis. It is not yet enabled by default, as we're
      still testing it.  You can try it with -new-matching option,
      but beware -- it can still contain some nasty bugs!

  The library:
    * Logging and accessor macros were improved.
    * Group is now also a member of the list variant.

  Bugfixes:
    * #520: indentation based syntax
    * #521: high memory usage when compiling mcs tests
    * #528: runtime assertion failure w/respect to generics
    * #530: antlr dll isn't compatible with mono 1.1.9
    * #531: Using generic method inside try-block fails to compile
    * #532: assertion failed in file typing/Subst.n, line 184
    * #533: Error using quoted events
    * #535: Double try in local function optimized to code causes error
    * #537: Verification fails for nondesc-subseq.n
    * #539: Failed CheckSTV with monad code
    * #540: Using void as generic argument causes invalid IL
    * #541: Requires macro do not work for property setter
    * #542: Logging macros should allow various logging functions to be
    	    used (and other improvements)
    * #543: Compiler gives internal error when trying to output into invalid
            directory
    * #544: .NET do not understand 'a ---> 'b implicit conversions
    * #551: { } brackets in string interpolation crash compiler
    * #553: Preprocessor symbols accessible from macros API
    * #554: Assertion about unsupported type for a complex generic hierarchy


0.9.0, Sep 13 2005
  The biggest change in this version is switch to the .NET 2.0 assemblies.
  The compiler now generates code using runtime generics when parametric
  polymorphism is used in Nemerle. While the language was designed with this
  switch in mind since the very beginning, the constantly changing and/or
  incomplete specifications forced us to make several changes to language
  semantics in this release.

  The intention behind the 0.9 version number is that we're now very
  close to the 1.0 stable release.

  We now require either Mono 1.1.9 or MS .NET Aug 2005 CTP. There are still
  several very serious issues with MS .NET S.R.E. API which may prevent certain
  features from working. Under mono there are problems with generic type
  serialization. 

  The performance of the generic code vary. Mono folks didn't
  implement shared code yet, which means generic code is JITed for each
  instantiation.  This isn't that bad as it first look though, after
  some tweaks that are already in the Mono 1.1.9 the performance is comparable
  to the non-generic version.
  
  In addition we should generate slightly better code overall with this
  version. The changes are mostly cosmetic though.

  There are some breaking changes in standard library API, because we dropped 
  our implementation of some generic classes in favor of .NET library classes.
  Most previously existing classes are still available though, but they are now
  subtypes of their BCL counterparts.

  About 500 SVN commits was made since the last release.


  Language changes:
    * Function types are no longer covariant on return type and
      contravariant on argument types. While in theory it is possible
      to employ co/contravariant interfaces here, it doesn't work with
      tuple subtyping (i.e. Func[int,string,float] is subtype of 
      Func[Tuple[int,string],float]). We have however provided implicit
      conversion for it, so in some cases it will still work.
      
    * Type variables of the enclosing type are now visible in static
      members (in addition to instance members). This also includes nested
      types. This is implemented by copying type variables of the enclosing
      type before type variables of the nested type. If you have:
        class A[X] {
          public class B[Y] { }
	  public clsas C { }
        }
      You can refer to A.B[int,string], A.C[int] as well as
      A[int].B[string] and A[int].C. Inside A[X] you can also refer to
      B[int] which means A[X].B[int] and to C which means A[X].C.

    * The 'matches' keyword is no longer supported.

  New features:
    * Generic specifier -- you can specify parameters of:
      - the generic type being created: Bar.[int] ();
      - the generic type some static member is accessed from:
        Bar[int].foo ();
      - the generic method: Bar.baz.[int] ();
      
    * Missing variables in matching branches can be now specified:
        match (some_list) {
	  // treat one element list as [x, x]
          | [x] with y = x
          | [x, y] => use x and y
	  // can also set several things at once:
	  | [] with (x = 7, y = 12)
	  // and mix with 'when'
	  | [x, _, z] when x == z with y = 17
	  | [x, y, _] => use x and y
	  | _ => ...
        }

    * Partial application on steroids. In ML you could apply two argument
      function to a single argument and get another single argument 
      function. We now support a similar, yet more powerful, feature:
        some_fun (e1, _, e2, _) 
      is transformed to 
        fun (x, y) { some_fun (e1, x, e2, y) }
      Partial application can be therefore written as 'f (x, _)'.
      It also works for member access:
        _.foo 
      will be rewritten to:
        fun (x) { x.foo }
      The two rewrite rules can be combined -- _.foo (3, _) will result
      in two argument function. Note that foo (3 + _) will probably not do
      what's expected (it will pass a functional value to foo). Use plain
      lambda expression for such cases.
      
    * Default parameters for local functions. This is mostly useful for 
      accumulators, for example:
        def rev (l, acc = []) {
          match (l) {
	    | x :: xs => rev (xs, x :: acc)
	    | [] => acc
          }
	}
	rev (l) // instead of rev (l, [])
      as you can see the initial accumulator value is placed in a more
      intuitive place. Any expression is valid as a default parameter value
      for a local function, but beware that it is evaluated each time the
      function is called without this parameter.

    * #pragma warning:
        #pragma warning disable 10003
	some_unused_function () : void {}
	#pragma warning restore 10003
      You can also omit warning number to disable/enable all (numbered)
      warnings. You can also specify several warning numbers separating
      them by commas.

    * Special implicit blocks are created around functions and loops.
      After using Nemerle.Imperative; it is possible to use "break",
      "continue" and "return". You can supply return value to "return",
      much like in C.
      More details at the blocks page: http://nemerle.org/Block
      

  Other stuff:
    * Alejandro Serrano is working on Code Completion Engine, that will be
      used be various IDEs. For now he integrated some support for code 
      completion in nemish (try System.Console.Wri**<enter>).

    * Kamil Stachowski provided syntax highlighting rules for Kate.

    * Language fixes in documentation courtesy of Kenneth Ismert.


  Bugfixes:
    * #156: Polymorphic type overloading does not work with dlls.
    * #173: Resource Embedding
    * #206: Apparent boxing bug in arrays
    * #277: Switch to framework 2.0 with generics, bugfixes and so on
    * #335: warning for $
    * #345: polymorphic interface method implementation checking is broken
    * #348: Members from current type are not accessible if looked up 
    	    through derived class
    * #350: Generic and non-generic types with the same name should be 
            different
    * #354: Private members of class should be accessible when we are 
            inside nested type of this class
    * #359: Accessibility checks for protected types performed by bind_types 
            crashes compiler
    * #369: typed macros queue
    * #381: Problems with casting to 'a.
    * #386: No special where-constraints: class, struct, new ()
    * #388: type variables are not visible from nested classes
    * #392: Null reference in generic code with ref parameters
    * #417: Static members should be first class players in generics typing
    * #423: the with ,,pattern''
    * #430: make ++/-- properly flag overflows
    * #435: Cannot use operators by their long names
    * #446: Container objects should show their contents
    * #450: Futile warnings when using Glade for Gui
    * #461: block return expression cannot be used to leave try block
    * #466: -disable-keyword compiler flag
    * #474: make generic specifier work
    * #475: add `42 kind of stuff to generic types in code generation 
    * #476: handle overloaded type names in binding types
    * #478: self calls not properly detected
    * #480: implement polymorphic local functions generation
    * #481: list of voids causes ice
    * #482: bug with delayed setter property typing
    * #483: delayed typing fails after null comparison
    * #484: ncc wrapper not available on linux system with binfmt_misc
    * #485: virtual or abstract methods using type parm are not overridden
    * #486: Problems with type inference on array elements
    * #487: Double importation of interface creates a 
            System.NullReferenceException
    * #488: I have no error - duplicate argument 'cx'
    * #489: Use C#'s algorithm for searching members in classes - walking 
            through hierarchy
    * #490: cannot unbox system.intptr
    * #491: Change NemerleMethod to MethodBuilder
    * #492: Cyclic generic types causes segfault
    * #493: Overloading fails to choose delegate when it is created 
            implicitly
    * #494: Elements initializing list are not properly boxed when list 
            unifies to list[object]
    * #497: crazy error message for incompatible types in two control flow branches
    * #498: parsing problem with matching
    * #499: Internal compiler error
    * #500: Wrong name type suffix used in macros/dataNpgsql.n with 
            mono 1.1.8.2
    * #501: IsRegistered failed
    * #502: invalid IL
    * #504: default parameters for local functions
    * #505: Variants should be not possible to inherit
    * #506: Enums should allow only numeric types as base
    * #507: interfaces sometimes confuse typer in case of foreach / 
            GetEnumerator usage
    * #508: Property need to be marked public in order to use public get 
            and private set
    * #509: Usage of 'array[2, int] * int' crashes the compiler
    * #510: unable to build 0.3.2 on OSX
    * #511: Unable to build nemerle trunk on OSX
    * #512: In the testsuite, positive/basic-value-types.n won't compile
    * #513: ** ERROR **: Invalid IL code at IL0007 in 
            _N_AutoModule:Main (): IL_0007: ret
    * #514: true when () compiles
    * #515: nemish prints an internal compiler error parsing a macro expansion
    * #516: abort() doesn't work
    * #517: nemerle fails to compile on OSX and Linux
    * #519: Nemerle.Imperative.Return/Break
    * #522: problem with string parsing
    * #523: compiler throws internal compiler error typing my continuation 
            monad
    * #525: problem with void->object conversions in nemish
    * #526: List literals don't work inside generic classes


0.3.2, Jun 1 2005
  This version brings a few new features and a bunch of bugfixes.

  New features:
    * You can now omit prefixes of variants and enums in matching, for 
      example:
        variant Foo { | A | B }
	match (some_foo) {
	  | A => ...
	  | B => ...
	}
	enum Bar { | A | B }
	match (some_bar) {
	  | A => ...
	  | B => ...
	}
      The restriction is that the type of some_foo need to be
      statically known to be Foo. If type inference cannot guess it
      at this point, you will have to match over (some_foo : Foo) or
      specify Foo.A in the first branch. Same goes to Bar.
      This feature is similar to switches on enums in Java 5.0.

    * Default parameters:
        public DoFoo (s : string, flag1 : bool = true, 
				  flag2 : bool = false) : void
        {
        }
      For boolean, integer and string default value the type of parameter
      can be omitted:
        public DoFoo (s : string, flag1 = true, 
				  flag2 = false) : void
      Only other allowed default value is null:
        public DoFoo (x : SomeClass = null) : void

    * The warning that you should use "FooBar where (...)" instead of
      plain "(...)" is gone. We have found that it was a mistake.
    * Blocks, it is possible to construct a block you can jump out of
      with a value. For example:
	def has_negative =
	  res: {
	    foreach (x in collection)
	      when (x < 0) res (true);
	    false
	  }
      Please consult http://nemerle.org/Blocks for details.
    * Tuples can be now indexed with []. It is only supported with
      constant integer indexes. Indexing starts at 0, so "pair[1]"
      is "Pair.Second (pair)".
    * Nemerle.English namespace now contains "and", "or" and "not" logical
      operators.
    * Macros can now define textual infix and prefix operators (just like
      "and" above).
    * Number literal can now contain _ for readability, for example 
        def x = 1_000_000;
    * Lazy value macros http://nemerle.org/Lazy_evaluation
    * Automatic get/set accessor generation http://nemerle.org/Accessor_macros
    * mutable can now define more than one variable:
        mutable (x, y) = (42, "kopytko");
        x++; y = "ble";
        mutable x = 3, y = "kopytko"; // the same
      The second version does not work inside "for (here;;)".
    * Arrays are no longer covariant. They haven't been in 0.2 days,
      and we have found it to be causing problems with type inference
      (see #442).
    * Tuples and lists are now serializable. Variants are deserialized
      properly.
    * Code can be entered at the top level, without a class and the Main
      method. So the classic example becomes:
        System.Console.Write ("Hello marry world!\n");
      That is, it put alone in the file will just compile. You can define
      classes, issue using declarations before the actual code. You can also
      define local functions with def (which gives you type inference).
      Yeah, we know this is only useful in write-once-run-once-throw-away
      kind of programs and testing, but it is nice anyway :-)

    * The CExpr compiler stage has been removed, which means that a/ we are
      more likely to implement generics soon, b/ we generate better code
      overall. Especially matching has been benchmarked and improved.
    

  Bugfixes:
    * Overload selection rules have been improved, especially in presence
      of var args, parametric types and named parameters.

    * #142: default parameters
    * #303: indexing operator on tuples
    * #351: Assigning to generic type's field does not yield its type's 
            argument specialization
    * #387: Exhaustiveness check of tuple patterns with variants is 
            exponential
    * #401: cannot define macros on assembly
    * #408: Do not create delegate proxy for instance methods
    * #409: Omitting the prefix when matching variants
    * #410: overload selection rules
    * #419: Logic operands in plain English
    * #422: _ in number literals
    * #426: macros assigned to local identifiers
    * #428: macros for lazy values
    * #434: /*\n Hang emacs
    * #437: Define more than one variable in the for( ; ; ) construct 
            - extend mutable definition
    * #438: Destroy CExpr stage
    * #440: bogus error messages about meanings of the module
    * #442: code generated for arrays forgets inferred type and crashes
    * #443: Wrong computation order when assigning the return value of a 
            function to a field during field declaration
    * #444: assertion in Typer2 when ignoring value
    * #445: delayed typings does not work on lhs of =
    * #447: Closurising caught value causes invalid IL
    * #449: implementing interfaces vs object subtyping
    * #451: -r:Nemerle.Compiler.dll
    * #453: Tuples are not serializable
    * #454: the ::= operator
    * #455: no warning for uninitialized members of struct
    * #456: Trying to escape block label crashes compiler
    * #457: Optional macro syntax extension not working
    * #458: Nemish fails to load profile.
    * #459: windows ncc.exe Url error
    * #463: matching compiler should use gotos not switches
    * #464: serialization and singleton pattern for variant options
    * #465: Unable to infer common type when there is also common interface
    * #467: get rid of TExpr.TailCall
    * #469: DecisionBuilder crashes on counterexample building
    * #470: inference for default parameters
    * #471: type inference does not work for enforcements
    * #472: preprocessor directive handling broken
    * #473: _ shouldn't be allowed in global types

      
0.3.1, May 2 2005
  This version is a quick fix for issues reported with the 0.3.0 release.

  Bugfixes:
    * The MSI package now have the proper version of cs2n.
    * The issues with loading external enums based on the long type
      are be fixed now.
    * Emacs mode should no longer hang on comment edition (#434).
    * There are quite a few language fixes in the documentation, thanks to
      Andy Burns and other nameless documentation updaters.

  There is a single nice feature that sneaked into this release, it is
  now possible to match inside the foreach loop directly (#436), that is:
    foreach (op in ops) { | Op.A => ... | Op.B => ... }
  will now work as:
    foreach (op in ops) { match (op) { | Op.A => ... | Op.B => ... } }


0.3.0, Apr 29 2005
  This is the long awaited 0.3 release :-)
  About 300 svn commits has been made since the last release.
  
  Additions:
    * The most important addition in this release are implicit conversions
      of several kinds.
      - We now respect user-defined op_Implicit (like the ones for
        Decimal type)
      - Functional values are implicitly converted to delegates.
      - when (...) 3; now gives a warning instead of error (about using
        implicit object->void conversion).
      - Last but not least, conversions are provided for built-in numeric 
        types like int and long. They work much like in C#. Here is 
	a picture about that:
	  http://www.c-sharpcorner.com/Language/TypeConversionsInCSharpRVS.asp
	This also works in a kinda special way for literals. There might be 
	some related bugs with constant folding though.
    * From the cute new features departments -- it is now possible to use
      pattern matching on properties, in addition to previous possibility
      of matching on fields.
    * Another nice addition are the P/Invoke methods.
    * The interactive interpreter -- nemerlish -- has been included in the
      default build and install.
    * Indentation engine in the emacs mode has been improved.
    * 'is' can be now used where 'matches' was. 'matches' shall be
      considered obsolete by now. It will give a warning in the next
      release.  
      There is one drawback with this change. If you have been using
      a polymorphic variant (like x is Some) on the right hand side of
      'matches' it won't work anymore. You either need to supply the type
      argument (x is Some [int]), you can use wildcard type (x is Some
      [_]), or make it a valid non-identifier pattern (x is Some (_),
      x is None ()).
      For the particular Some/None you can use freshly added 
      IsSome/IsNone properties.

  Incompatible changes:
    * The arithmetic operators on types smaller than int now return int.
      This is the same behavior as in C (and C#).
    * Various matching optimization flags have been removed (they now
      print a warning). Boolean optimizations are now always enabled,
      while the other were buggy. Patches are welcome.
    * Progress bar is now disabled by default. You -bar+ switch to turn
      it on (we found people very often disable it, and it confuses
      emacs).

  Library:
    * List manipulation functions have been added to the list type itself.
      
  Bugfixes:
    * The MSI package now properly installs itself in the directory
      specified, not always in "c:/Program Files/Nemerle/".
      
  Fixed bugs from our bugtracker ( http://nemerle.org/bugs/ )
    * #007: Static variable initalization in metadata
    * #119: subtyping relation for numeric types
    * #138: matching on properties
    * #249: functions are not "boxed" to delegates
    * #256: Should we implicitly convert from DateTime to SqlDateTime
    * #284: a=b-1U; does not parse
    * #316: Allow PInvoke methods
    * #334: Custom operators are not looked up properly
    * #343: Algorithm for binding base classes is broken
    * #360: Inference engine loops compiler when parameter is used on itself as function
    * #364: support ++/-- overloads
    * #383: Assigning to variable with name of type
    * #390: Problems with the $-notation
    * #391: Explicit cast operator is not chosen when needed
    * #393: Using nested foreach crashes compiler.
    * #394: We do not check attribute targets
    * #395: Another meaningless error message
    * #396: ncc crashes during typing of foreach loop on N.C.Hashtable
    * #397: ICE when fixing type of local function
    * #398: return type is not checked in delayed overloads
    * #399: comparing with == against null shall not be special
    * #400: strange problem with delayed typings and overload resolution
    * #402: cannot use _ in keywords
    * #404: $ "$Name" doesn't work -- usesite problems
    * #406: Something is broken with expected return types
    * #407: Lambdas from embedded expressions crashes compiler
    * #414: comparing ,,result'' of mutable definition to null causes ICE
    * #418: Literal fields should be available in match patterns
    * #420: Nested types are not visible in derived class
    * #421: Add implicit conversion from 0 to any enum
    * #424: merge the literals branch
    * #431: Change 'matches' to 'is'
    * #432: ice with foo(){| _ => {}}


0.2.10, Mar 31 2005
  This is another preview before 0.3.0. We have fixed a handful of bugs
  and decided to give it another shot.
  About 100 svn commits has been made since the last release.

  Additions:
    * There is Nemerle NAnt task included in the distribution.
    * The XSP (ASP.NET) integration has been tested and documented,
      please refer to http://nemerle.org/wiki/ASP.NET
    * We do not support binary installation from tarball -- bootstrap is
      now always required.

    * A Nemerle syntax file genShi has been added to the distribution and is 
      now used in our Wiki for colorizing sources.
    * Tests are now run using Nemerle.Compiler.dll as a library -- it is 
      a lot faster.
    * New -greedy- option to disable recursive loading of assemblies.
    * We now support Windows style /options.
    * Yet incomplete support for new(), class() and struct() generic
      constraints.
  
  Bugfixes:
    * The SQL macros should now compile fine.
    * We now support creation of delegates from external static functions.
    * Installation issues with and without antlr should be now resolved.
    * Error message involving types and custom attributes should be better 
      now.
    * Quotations in response files are handled properly now.
    * Documentation updates.
    * Snapshots/SVN now use * as last part of assembly version, which should
      cure all already-installed-to-the-GAC build problems.
    * We treated type[] as a generic type with no arguments. This is fixed 
      now.
  
  Fixed bugs from our bugtracker ( http://nemerle.org/bugs/ )
    * #302: there should be nemerle.pc file
    * #334: Custom operators are not looked up properly (there is still
            some issues here)
    * #340: Enum options with lowercase name are wrongly understood in patterns
    * #362: access rights are not checked for property accessors
    * #372: Typer crashes when match results are first System.Enum then null
            (matching enum values)
    * #375: ice in null pattern exhaustiveness check
    * #377: wrong error message for accessing instance from another class
    * #380: nemerle from MSI package have problems with loading 
            Nemerle.Macros properly [a killer bug]
    
  
0.2.9, Mar 22 2005
  This is preview release before 0.3.0, which is real soon now. There
  are lots of changes in this version -- the parser and the typer
  (which constitute more then half of the compiler) have been replaced
  by entirely new implementations.

  There is a number of backward incompatible changes in this release.
  Most of them were previously discussed on the mailing list, and
  received rather good feedback other only generate warnings in this
  release. We apologize for both. We hope they make Nemerle a better
  language. On the plus side -- we should be now far closer to certain
  language stabilization point.

  0.3.0 should bring implicit conversions, List iterators as list[T] methods
  and maybe some more goodies.
  
  Incompatible language changes:
    * Variant options are now nested inside enclosing variant, so their
      names need to be prefixed with variant name. For example:
        variant Foo { | A | B { x : int; } }
        ...
        def x = Foo.A ();
        match (some_foo) {
          | Foo.B (3) => ...
	  | _ => ...
        }
      You can mark variant with [ExternallyVisibleOptions] to import its
      options outside the variant or open variant name with 'using'. 
      More details in this thread:
      http://nemerle.org/mailman/pipermail/devel-en/2004-September/000256.html
    * Generic types use now [] instead of <>. That is there is 'list [int]' not
      'list <int>'. This is the second (and hopefuly last ;-) time we change it.
      More details in this thread:
      http://nemerle.org/mailman/pipermail/devel-en/2004-September/000259.html
    * Record patterns like '{ foo = 42; bar = 3 }' are now deprecated. New 'where'
      patterns have been introduced, to explicitly mark the class used for 
      matching:
        | Foo.Bar where (x = 3, y = Qux) => ...
        | Foo.Bar where (3, Qux) => ...
      Variant patterns now also support field names:
        | Deep.Though (x = 7) => ...
    * The ':' operator in patterns should from now on be only used to statically
      enforce type. Runtime type checks should be performed with the 'is' 
      operator which uses the same syntax:
        match (some_list) {
          | (x : int) :: xs => OverloadedFunction (x); loop (xs)
	  | [] => {}
        }

        match (some_expr) {
          | x is Foo => ...
	  | x is Bar => ...
	  | _ => ...
        }
      Trying to use ':' or 'is' in the other context will rise warning. It 
      will be hard error for ':' used as 'is' in future release.
    * The catch handler syntax has been changed to reflect change in 
      matching:
        try {
	  ...
	} catch {
	  | foo is SomeException => ...
	  | bar is Exception => ...
	  // or | bar => ...
	  // or | _ => ...
	}
    * Macros can no longer be nested in classes
    
  Language additions:
    * Added <<, >>, |, ^ and & operators. %|, %^ and %& remain there.
    * It is now possible to ignore values like this:
        _ = ignore_me (17);
    * It is now possible to assign stuff to tuples, like this:
        mutable x = 7;
	mutable y = "foo";
	(x, y) = (42, "bar");
    * Function parameters can be now marked 'mutable'.
    * The 'partial' modifier on classes is now supported.
    * '{ def _ = foo; }' is now allowed without the additional '()'
      at the end.
    * New 'throw;' expression to rethrow the exception.
    * The type inference engine has been replaced by a new one:
      - code like this compiles fine:
          def foo (x) { x.bar () }
	  List.Map (some_list, foo)
	when the type of 'some_list' is known.
      - overloading resolution now works when passing functional values:
          List.Sort (some_list, string.Compare)
      - variant option's constructors have now proper type, that is there
        is no longer need to 'SomeVariant.Option () :> SomeVariant.Option'
      - stuff like 'array [A (), B ()]' should now work (if 'A' and 'B' have a 
        common supertype)
    * Add 'repeat (times) body' language construct

  Library changes:
    * IMap.Fold used to use reverse parameter order then other fold 
      functions. It is fixed now.
    * A new Set class has been added.
    * Nemerle.Collections.Vector is now enumerable (patch by nuffer).
    * New functions in List:
      - MapFromArray
      - GetElementType
      - Contains
      - ContainsRef
      - FirstN
      - ToString (separator : string)
    * List Length() and IsEmpty() are now properties.
    * New functions in Option:
      - Iter
      - GetHashCode override
    * Stack.Top() is now a read/write property.
    
  Macro library changes:
    * Concurrency macros based on implementation of Polyphonic C# 
      has been added (implemented by Ricardo).
    * The foreach macro now uses semantics consistent with matching:
      foreach (s : string in foo) requires elements of foo to be of
      statically known type string, foreach (s :> string in foo)
      casts each element of foo to string (raising exception in case
      of problems) and foreach (s is string in foo) executes the loop
      body only for strings in foo.
    * Assertions macros now have new syntax extensions available. They can be
      used like in http://nemerle.org/macrouse.html#designbycontract
    * Added macro library for type-safe SQL operations with MS SQL Server
    * Diagnostics macros now have parameterless Trace macro and 'time' macro
      for measuring performance of some chunk of code
    * Quotations of patterns, types and expressions are now unified to simple use
      of <[ some code ]>
    * Added OverrideObjectEquals macro for automating overriding of
      Equals (object) method with type-safe Equals (SomeType) method

  Other stuff:
    * Parser has been changed, it gives better error recovery, forward
      lookup and capability of deferring parsing in syntax extensions 
      (see http://nemerle.org/mailman/pipermail/devel-en/2005-March/000427.html)
    * We have a new tool -- a C# to Nemerle converter. It produces
      human-readable Nemerle sources. 
    * We have added over 300 converted testcases from MCS. ncc
      behaves now far more sane and C#-like especially at the class level.
    * The -doc switch can be now used with NDoc. You can have a look at
      the example output: http://nemerle.org/doc/
    * Some warnings can be now disabled by-number, there is also -warn
      warning level switch.
    * Simple Nemerle interactive shell has been included in the distribution.
    * The debug symbol output should work under MS.NET.
    * The Sioux webserver has been greatly extended.
    * A syntax highlighting file for Midnight Commander editor.
    * The htmldumper tool has been written -- it creates pretty Nemerle 
      sources for the web.
    * It should be now easier to compile Nemerle on Windows using MinGW.
    * Lots of performance work -- in the compiler, the library and the 
      generated code.
    * Lots of bugs hunted.


0.2.1, Sep 18 2004
  This is a bugfix release to quickly fix issues found in 0.2.0.
  
    * Include *.snk key files in source tarball.
    * Fix bug with typing of write-only properties.
    * Allow $ "$$" to mean "$". Patch by Mike Roome.
    * Bitwise operators on enums without [Flags] generate warnings now,
      instead of errors.
    * value__ enum fields are now marked with rtspecialname (fixes
      verification problem).
    * try-blocks found inside of expressions now generate errors instead of
      invalid IL, it is going be investigated later.
    * The compiler now looks for libraries in directory it was run from.
    * 'foreach' macro can now take arbitrary pattern as argument, like

      foreach ((Some (x), y) in collection) {
        print (x, y)
      }

    * Fixed a few minor bugs in heap implementation, defining of command-line 
      preprocessor symbols, pretty printing of macro expressions, etc.
    
0.2.0, Sep 12 2004
  This version makes the Nemerle language full CLS consumer and producer.
  A number of non-CLS features are also in place, for C# compatibility,
  but we do not yet support CLSCompliant attribute checking. Any lack
  in CLS compliance is a bug now.

  The language:
    * Multidimensional arrays are now supported. This features was
      implemented by Ricardo Fernandez Pascual. The syntax for array
      types is: array <3, int> for three-dimensional int array (int[,,]).
      array <2> [[1, 2], [2, 3]] and array (2, 2) can be used for array
      object construction.
    * Fields can be now embedded in properties:
    
        public Foo : int {
          mutable foo : int;
          set { foo = value; }
          get { foo }
        }
	
      They are invisible outside the property.
    * base.foo() and base.foo now work properly.
    * Attribute targets (like [assembly: ]) are now supported. This finishes
      custom attributes support.
    * @"foo""bar" works now as described (as in C#, "foo\"bar"). Patch
      by Scott Fleckenstein.
    * The () can be now omitted in (foo :> int) and (foo : int).
    * A typecase:
        
	match (foo ()) {
	  | x : SomeType => x.field_of_sometype
	  | x : SomeOtherType => ...
	  | x : object => // always matches
	}
	
      The `:' pattern can be also used inside other patterns:
        
	match (foo ()) {
	  | [x : Foo] => ..
	  | _ => ..
	}

      The `is' operator, known from C# has also been added.
    * The `matches' operator has been added for one case matching:

      expr matches pattern == 
      match (expr) { pattern => true | _ => false }

      It is to be reconsidered, if `is' can be used for both purposes.
    * The `volatile' modifier is now respected and supported.
    * checked/unchecked are now supported, as seen in C#.
    * Other instance ctors can be now called from current ctor, using 
      'this(...)' syntax.
    * Delegates can be now produced.
    * Structs (classes that are value types, i.e. they are passed by
      value) are now supported. Tuple2 and Tuple3 internal types are now
      structs for efficiency.
    * Varargs functions (using `params' keyword, before array argument)
      are now supported.
    * All value objects have now implicit parameterless constructor,
      like in C#.
    * Usage of the `<-' operator (where `=' should be used) now generates
      a warning. It will be removed in a release or two.
    * The implicit constructor for value types can now be used. For example:
    
        def x = int ();
        def y = SDL_Event ();
    
    * Indexers can be now defined. Non-default indexers can be now
      referenced.

        public Item [x : int] : string { get { item [x] } }
        public FooBar [x : int, y : string] : int { 
          get { foo (x, y) }
          set { set_foo (x, y, value) }
        }

      The default indexer is always called `Item' currently. It can be
      accessed using x[3] as well as x.Item[3].
    * Enums can now be declared with expressions as values.
    * An implicit empty class ctor is now added as in C#.
    * `namespace X = G.D;' is now `using X = G.D;' (as in C#). The former
      form usage generates a warning.
    * New cool string interpolation feature -- the `$' operator is now
      shorthand to Nemerle.IO.sprint, example usage:

	def x = 40;
	def y = 42;
        System.Console.Write ($ "$(x + 2) == $y\n")

      Any expression can be used in $(...), but there might be problems
      with embedded strings and so on. It is meant to be used with simple
      expressions like array/field access, method call and so on.
    * The `==' has no fallback to reference equality now. This means, that
      if a class and its base classes have no overload for the `=='
      operator, then using `==' on it is an error. There are two
      exceptions: if (at least) one side of the `==' operator is
      (exactly) of the System.Object type, or one side of the `=='
      is the null literal, then reference equality is checked.
      A few bugs in the compiler was pointed out by this (more restrictive
      then in C#) feature. The same goes for the `!=' operator.
      
      All that means, that given:

        class A { }
        class B : A {
          public static @== (_ : B, _ : B) : bool { true }
        }

      The following is OK:

        (A () : object) == (A () : object) // false
        (A () : object) == A ()            // false
	A () == null                       // false
	(null : A) == null                 // true
	B () == B ()                       // true
	B () == null                       // true
	(B () : object) == null            // false
	(B () : object) == (B () : object) // false

      And the following are errors:
	
        A () == A ()
	A () == (null : A) // (null : A) is not null literal
	(B () : A) == (B () : A)
      
      
  The library:
    * Bugfixes in queue implementation.
    * Nemerle.Utility.Pair module added, with 3 little functions.
    * The foreach() macro is now optimized when used on arrays and lists.
    * Lots of reworking and rewrites, particularly introducing properties
      instead of methods here and there [[Pawel, maybe you can describe it?]]

  The compiler:
    * KeyFile, AssemblyName and Version attributes are now supported, with
      their special semantic meaning derived from C#.
    * -r option can now load assemblies from the GAC by strong name.
    * Nemerle assemblies can now be stored in the GAC, make install uses
      gacutil now. Beware of make boot problems, when the same version of
      Nemerle is installed in the GAC. Mono 1.0 is now required under Unix.
    * Fixes in constant loading, particularly decimals.
    * Using the obsolete `<-' assignment operator triggers now a warning.
    * New -resource and -linkresource switches for embedding/linking 
      resources into executables.
    * Lots of other bugfixes.

  Other stuff:
    * Sioux has been extended, generalized and documented.
    * CodeDomProvider for Nemerle has been submitted by Atsushi Enomoto.
      There is some preliminary work on XSP supporting Nemerle ASP.NET pages.
    * Async methods macros have been written by Ricardo Fernandez Pascual.

  
0.1.4, Jun 29 2004
  This is yet another incremental release before 0.2.0.

  The language:
    * The assignment operator <- has been changed to =. This was a long
      discussed issue. <- is still available, it will be deprecated in 
      0.2.0, and removed later. Please convert your sources, under Unix:
      
        perl -p -i -e 's/<-/=/g' *.n
	
      should do the trick.
    * The `;' is now optional after `}' in expressions. That is both:
    
        while (cond) { ... };
        foo ()
	
      and
      
        while (cond) { ... }
        foo ()
	
      are correct.
    * Expressions starting with keywords have now much lower priority.
      In particular:
      
        foo += fun (_) {...};
	
      needs to be now written like this:

        foo += (fun (_) {...});

      Sorry. This is however to be reconsidered.
    * 1_000_000 is now proper literal (like in Ada or Perl).
    * ref and out parameters are supported now.
    * try {...} catch {...} finally {...} is now proper code, 
      try { f () } catch {...} is too, but try f () catch {...} is not.

  The library:
    * Tuple and list types now provide proper ToString(), Equals() and 
      GetHashCode() methods.
    * List.Sort() was sorting in the opposite direction, we fixed that. Please
      update your sources.

  The compiler:
    * Some fixes to attribute support, in particular attribute classes
      can be defined and used in the same compilation.
    * Several new checks (like requiring implemented interface methods 
      to be public etc).
    * Several bugfixes.

  Other stuff:
    * Added examples written by students during Nemerle course. Some new
      OpenGL/SDL examples by Kamil.

  
0.1.3, May 30 2004
  This is an incremental release before 0.2.0, it has some more .NET
  connectivity features, although a few things are still missing (before
  we can call Nemerle a CLS extender).

  New language features in this release:
    * Properties and events can be now defined. Syntax is mostly the
      same as in C#.
    * Basic custom attribute support has been added. We do not support 
      attribute targets nor attributes on parameters yet.
    * Enums can be now defined.
    * +=, -=, *= etc operator on numbers.
    * Delegates can be now invoked like d() (not only d.Invoke()). 
      += and -= operators are overloaded for events and delegates to do
      The Right Thing(tm).
    * Macros can be now defined on declarations (types, methods, fields 
      etc). They are run using attribute syntax.
    * Preprocessor supporting conditional compilation has been added. 
      It shares semantics with one from C#, -define (aka -D) flag is also 
      supported.
    * Methods can be now defined inside variants. Thus a few library
      changes, like addition of ToString and + operator to list type.
    * Operators can be now overloaded (in addition to adding new).
    * Fields in classes can now have initializers (these are added
      to ctor).

  Other stuff:
    * External types are now stored in a specially crafted tree. All types
      are loaded on startup, but this saves time later.
    * Syntax extensions tied to macros are now activated only within
      namespace of given macro.
    * -pkg-config switch has been added, so external libraries (like
      Gtk#) can be easily linked, using -pkg:gtk-sharp.
    * -no-stdlib option now prevents mscorlib.dll and System.dll from being
      loaded, -library-path now works for them too.
    * ncc can now handle @response files.
    * Matching is being reworked, matching on variants is now a lot faster 
      than it used to be.
    * Some hacks to allow mono GAC usage (available in mono 0.91+, we do *not*
      require this beta version though).
    * There is new [Record] macro that adds record like constructor to given 
      class, there is no automatic constructor creation except for variant
      options now.
    * API for changing types from macros is being constantly reworked
      and improved.
    * List.Member and the like instead of physical == equality use Equals()
      method.
    * Several bugfixes, some critical, as usual.

0.1.2.1, Apr 30 2004
  This is just a quickfix -- some files were missing in tarball. There
  is also a slight macro documentation fix.

0.1.2, Apr 28 2004
  This release brings several important bugfixes, more documentation
  (great thanks to our techwriter for making it more readable) and
  improvements in macro subsystem.

    * Macros are now hygienic -- that is each macro invocation introduces
      new virtual namespace for generated names. See meta-programming paper
      for details.
    * Macros themselves now sits in namespaces. Notable example is printf,
      that is now Nemerle.IO.printf. You will need to update your sources.
      Common macros (like if and while) are in Nemerle.Core, so no changes
      are needed.
    * Symbols in macro quotations are now bound to their global meaning
      (e.g. imported namespaces, nesting in modules) at the place of 
      quotation definition, not the place of macro use.
    * The <-> operator now properly computes each expression just once.
    * Loading assembly with -r flag now loads also all assemblies
      referenced by it.
    * New integer operators <<, >>, %|, %& and %^ for common bitwise
      functions.
    * New -- and ++ prefix operators for decrement/increment (both return
      void).
    * Events can be now accessed with add_EventName and remove_EventName,
      no +=/-= syntax yet.
    * Full support for various integer and floating point types (like uint,
      long, double etc). Literals like 0u, 0l, 3.14f are now also supported.
    * System.Windows.Forms examples can now be compiled.
    * "foo" "bar" is now single string literal.
    * Added preliminary SQL helper macros.
    * Reordered parameters of Fold and Map in Hashtable to match List.
    * Few fixes in error messages.
    * Several other bugfixes (particularly with code generation and boxing).
    * Compiler now properly checks if type of field/method is as accessible
      as the field/method itself.
    * Resolved some lengthy compilation issues with Gtk# and 
      System.Windows.Forms types.
    * Resolved problem with literal fields on Windows.
    * Under Unix we now require mono 0.31 or later,

0.1.1, Feb 24 2004
  This is mainly bugfix release.
  
    * Fix bugs with tail call elimination (that lead to stack overflows 
      with simple loops).
    * Introduce new optimization of tail-loops, that doesn't require any
      allocations now.
    * Add -o alias for -out command line option, so ncc behaves in more
      standard way.
    * Fix type cast in foreach macro, it should now work.


0.1.0, Feb 17 2004
  First public release.
