0.9.4, Feb 22 2008 Mono 1.2.3 (or .NET 2.0) is required by this Nemerle release. Compiler/language: * Co/contravariant generic parameters in interfaces and delegates. They take advantage of MSIL level feature, which currently works only under MS.NET. http://nemerle.org/Quick_Guide#Co-_and_contra-variance * Exception handlers can now have 'when' clauses, just like in regular matching. * [Obsolete] attribute now causes warnings where it should. * Code like match ([]) { | _ :: _ => ... | [] => ... } will now generate warnings about unused branches. * The type of fields that are initialized in place, can now be inferred (in some cases at least). * We now enforce the requirement to use UTF-8/16/32 as encoding of the source files (i.e. the compiler dies when it sees invalid UTF sequence). * Yet another way of quoting string literals is supported: <# ... #>. It can be nested and is meant as an aid in implementing DSLs using macros. Internal changes (may affect macros): * Lots of compiler internals has been refactored from modules to normal classes. Library changes: * Additions in RList. * More utility functions in NArray (also as extension methods). * Some collection classes now display nicely in VS debugger. Macro library changes: * Method aliasing macro. * Late binding macros (need testing/comments!) [link?] * 'expr ?? default' operator as alternative to 'if (expr != null) expr else default' * The '**' operator is an alias to System.Math.Pow now. * SQL macros are included in standard library and can now be used with any DB .NET provider * NemerleUnit unit test language base on NUnit is now also included: http://nemerle.org/NemerleUnit Other stuff: * Added Nemerle.Contracts with some limited Boogie (Spec#) support. * Nemerle Documentation Project (NDP) is included with the compiler -- it is meant to generate HTML from XML produced by ncc from Nemerle sources. * A .NET Reflector addon for Nemerle is now distributed with the Nemerle source code. Fixed issues from BTS: * #179: when support in catch{} blocks * #349: Interfaces should be possible to reimplement second time * #368: sum type for overloaded call result * #415: Something is not properly interpreted when using event without this. prefix * #441: problems with constraints put too early on overloads * #534: evil warning for unused clause, related to null pattern * #538: Lambda changed into delegate should not create functional value or delegate proxy * #552: More type inference needed in nested local function * #638: Co/contravariance for generic interfaces / delegates * #676: Type alias expands to wrong generic type when used to construct new instance * #678: A successful compilation yields invalid IL * #683: Loading Nemerle.Macros.dll if it placed in GAC * #684: pseudo quotation issue: generic type parameters are not fully spliceable / not programmer friendly * #686: nemerle.indent.vim cause busy loop. * #687: invalid il for generic function returning closure * #688: Can't cast array of reference type to covariant subtype * #690: ncc: assertion failed in file ncc\typing\Typer.n, line 149 * #692: Incorrect debag information * #693: type inference fails when concatenating list comprehensions * #695: Incorrect exception catch behaviour * #697: Can't get type of generic attribute * #699: [0.9.3] Add ability to use $(variable : enum) in <[ ]> * #701: [0.9.3] Empty structs have $PLACE_HOLDER$ field * #702: [0.9.3] When downcasting IL generates unnecessary .castclass * #703: [0.9.3] Immutable fields are not marked with initonly * #704: Nemerle allows static constructor with parameters * #705: cs2n makefile prevents building cs2n with msys * #706: Implicit cast func type to delegate. * #707: Bug in Extension method implementation * #708: Internal compiler error for mutable without initializer in quoted expr * #710: 'is' not allowed on generic parameters * #711: Self referential use of generic from assembly fails * #712: Nested generic type problem * #713: Problem with 'regexp match' macro * #715: Cannot implement interface when interface already implemented on base class * #716: Small typo patch for CodeCompletionEngine.n * #717: Can't match array * #718: Create delegate for local function * #719: NotNull doesn't work with generic function parameters * #720: msi: Incorrect quotation in env. variable * #723: "Typing fails on ambiguity between overloads" for correct code * #725: Warning: unexpected end of file. Current depth is 2 Line 8, position 11. * #726: Internal compiler error * #727: Problem with functions and tuples * #728: "Duplicate parameter name" with new lambda syntax * #729: complex use of Co/contravariance for generic interfaces / delegates * #730: Aliases not expanded in nested using directive * #731: Compiler ices when trying to use OfficeXP interop assemblies * #732: Nemerle.Imperative.Continue makes foreach loop forever * #733: Short match & anonymous functions * #734: Inernal compiler error in foreach in nested function * #735: cannot specify 'new' for interface member * #736: ObsoleteAttribute support * #737: Referenced namespace does not exist error. * #738: Override generic method * #739: Try block is not allowed inside expressions * #740: Unregistered local when macro emits typed expression * #741: Coment in pragma * #742: Strange namespace opening behaviour from within namespace * #743: Nemerle Ices on .ctor with default parameter when classname is same as already imported * #745: Automatic generation of untupled contructor should call existing one instead of base() * #748: "using" in the body * #751: Dependence compile result from order of source files in the ncc command line * #752: ref parametrs bug * #753: Internal compiler error * #754: Incorrect parse comments * #755: Confusing error * #756: 'Internal compiler error' if try use closures in yield-method * #757: Compilation Error with the September VS SDK installed * #759: multiple type conversion operators * #764: The partial application don't work with :> operator * #765: Extension methods overloads and property * #767: Can't implement generic interface methods. * #768: Explicit and implicit conversation problem with generic types. * #769: Can't subscribe on event if 'Nemerle.Collections' namespace opened * #770: subtle overloading resolution bug, involving type inference of local functions * #771: Add manager : Manager parametr to assembly level macros (metaatribute) * #774: Internal compiler error * #775: Internal compiler error * #777: internal compiler error on recursion with ref parameters * #778: Record macro & field init * #780: ICE - unsinged (and other) values in constant folding of bit operators * #781: Run-time exception on %&& * #782: Internal Compiler error (assertion failed in Typer4.n) * #783: ICE in Nemerle.Compiler.TyCodec+_N_set_constraints_17377.apply_void * #785: Incorrect treatise 'new' keyword (it bug block compilin of compiler) * #787: Invalid warning * #788: Add / Remove reference * #789: Incorrect type is inferred in lambda expression when iterated list consists of members that support multiple interfaces * #790: Wrong error message when trying to access nested variant subtype * #791: Doesn't allow to complete namespaces * #794: Imperative return + option = crash * #796: ICE with $(TExpr.Something : typed) * #797: problem with caching of properties returning arrays * #798: unexpected token after expression in sequence * #799: ICE: can't compile Nemerle.Compiler.Utils project * #800: System.Void as a generic type argument * #801: Invalid IL for cast between two generic parameters * #802: Nemerle.Evaluation fails * #804: Self tail calls should not be used in virtual methods * #805: Does not report inability to infer type arguments * #806: cast issued instead of conversion * #807: GetHashCode in DecisionTree can throw OverflowException * #808: Invalid IL generated for generic cast from void * #809: problem with 'mutable x : Type' * #811: Funny error: used to have type System.Object but now it has type System.Object * #813: Array cast fail * #814: Nemerle default indexer not compatibility with C# * #815: if/else generates unneccessary code * #817: Compiler allows calling base abstract member * #821: Can't set breakpoint on return value * #823: wrong error message for when( fun_returning_string ) ; * #826: Match and inheritance * #828: Mono doesn't implement conv.ovf.u4.un; Nemerle generates it * #831: Invalid IL with RList.Update (other methods work fine) * #836: Parsce } * #838: 'throw' instruction without argument shall be disallowed outside of catch block * #839: throw; inside finally clause * #840: Ambiguity between overloads * #847: 'base' shall not be a valid assignment target * #849: Regression: Ncc does not allow 'throw' inside 'try' inside 'catch' * #853: Single-paren syntax for match over tuple * #854: Ncc hangs if there is a circular dependency * #856: Enums shall not be polymorphic * #859: Do not allow to overload solely on ref and out * #860: Partial structs shall be allowed * #864: Ncc hangs on zero-dimensioal array * #865: ICE on negative-dimensinal array * #868: ICE * #869: ICE if namespace name is used in new object creation expression * #870: Function composition operator & Pipeline operator * #872: ICE on too-many-dimensional arrays (>32) * #873: ICE on decimal literal * #875: StackOverflowException inside ncc, if there is a circular depenedcy in source * #876: Bug in hexadecimal literal parser * #881: Bogus error concerning override * #885: Interface member mapping on member, inherited from base class * #887: Bogus error (got void in function return type) * #890: Missing closing brace is not reported * #893: Tuple's Equals method throws NullReferenceException if called with null argument * #894: Tuple's Equals method throws NullReferenceException if the tuple has a null element * #895: Tuple's ToString method throws NullReferenceException if the tuple has a null element * #896: Typo in filename 'VSIntegartion.nunit' * #900: Visual Studio crashes due to recursion * #901: It is impossible to deserialize Hashtable * #904: Property accessor may not be more accssible than the property itself. * #905: VS crashes if there is a cyclic inheritance * #906: Allow private accessor in non-private virtual property * #907: Entry point may not be a method in polymorphic type. * #908: ICE if typeof is used without argument * #912: VS crashes if there is a cyclic tuple dependency * #913: Abstract ctors shall be disallowed * #914: Fix typo in Manager.IsCompletioInProgress * #916: VS crashes if there is a cyclic local functions dependency * #919: Symbol highlighting works bad, if there are more than one overload * #924: ICE on bad pattern * #928: Bogus error highlight (unbound name 'o') * #937: Fix CanBeTypeName in Typer.n * #939: build under win64 * #941: ICE on wrong out/ref types * #943: Ncc (build 7471) builds itself, but it fails to build VS Integration. * #944: fixes in parsing hex literals * #945: parsing preprocessor errors * #946: parsing preprocessor if vs region * #950: "when" isn't in _topKeywords * #953: ICE * #956: preprocessor conditions are not strictly checked * #957: match nullable generates bad IL * #958: Exception leads to not working project (after Vlad's changes to lib loading) * #959: Build 7499: VS crashes, when I create new Nemerle project * #960: Exception in AssemblyLoadFromImpl (library loader) * #961: Preprocessor: syntax of "if elif* else? endif" is checked wrong * #962: Primitives implicit conversation. * #963: Hints do not show in Output window * #965: Build.cmd has a bug * #967: NUnit 2.2.9 * #968: unmanaged resources * #969: Cannot build Nemerle compiler * #970: ICE where variant in <[ ]> block (revision 7525) * #974: ICE in <[ decl: $( [ ..$fields ] ) ]> * #976: closure with "this" in constructor * #977: Typer3..ctor(Typer3,MethodBuilder) explicitly calls base(..) twice * #984: Ugly error message if incorrect default value for parameter * #986: value type base ctor * #992: Nemerle.Data.ExecuteReaderLoop macro: nullable types from DB 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**). * 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 '. 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.