[Mono-list] Nemerle 0.3.0 released

[Michal Moskal]

Hip! Hip! Nemerle 0.3.0 is out there in the wild.

This is the long awaited second milestone release (after 0.2.0 -- CLS=20
consumer) with a new typing engine and a new parser.

Nemerle is a high-level statically-typed programming language for the
.NET platform. It offers functional, object-oriented and imperative
features. It has a simple C#-like syntax and a powerful meta-programming
system.

Features that come from the functional land are variants, pattern matching
and type inference and parameter polymorphism (aka generics). Meta-system
allows great compiler extensibility, embedding domain specific languages,
partial evaluation and aspect-oriented programming.

The source tarball can be downloaded from:

  http://nemerle.org/download/nemerle-0.3.0.tar.gz

and:

  http://nemerle.org/download/nemerle-0.3.0.tar.bz2

MSI, DEB and RPM packages (as well as the source tarball of course)
as usual from:

  http://nemerle.org/download.html

The binary packages may have a small lag to the source release.

New features in this release include (from the NEWS file). This list can
be also found nicely htmlized in a blog post:

 http://nemerle.org/blog/archive/2005/Mar-31.html
=20
0.3.0, Apr 29 2005
  About 300 svn commits has been made since the last release.
 =20
  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=
=20
        types like int and long. They work much like in C#. Here is=20
=09a picture about that:
=09  http://www.c-sharpcorner.com/Language/TypeConversionsInCSharpRVS.asp
=09This also works in a kinda special way for literals. There might be=20
=09some 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. =20
      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=20
      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.
     =20
  Bugfixes:
    * The MSI package now properly installs itself in the directory
      specified, not always in "c:/Program Files/Nemerle/".
     =20
  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=3Db-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 =3D=3D 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(){| _ =3D> {}}


--=20
   Michal Moskal,
   http://nemerle.org/~malekith/