Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

1917 lines (1697 sloc) 92.877 kb
1.0.0 Release Candidate, Feb 05 2011
Mono v2.6.x+ (or .NET v2.0 SP1) is required by this Nemerle release.
Compiler/language:
* Added back pipe operator <| and back composition operator << as opposed to |> and >> to replace parenthesis in indent mode.
Visual Studio Integration:
* Snippet VS2010 now compiles.
Other stuff:
* Breaking changes in ComputationExpressions. Added AsyncValue class to prevent some misunderstandings in code.
* Build for .NET 4 has been improved for compiler project.
* Build for .NET 4 has been added for PowerPack projects.
* Now it is possible to build full featured Nemerle environment by simply call DevBuildQuick.cmd.
Fixed issues from tracker:
* #1163: Wrong behavior: IEnumerable[int] and array[int] are not compatible.
1.0.0 Release Candidate, Jan 16 2011
Mono v2.6.x+ (or .NET v2.0 SP1) is required by this Nemerle release.
Compiler/language:
* Added AutoPropertyField for PropertyBuilder.
* Added syntax support for get-only properties.
* Added implementation of External Parsers API.
* Implemented bypass of constructor parameter creation for abstract get property.
* Added warning (N10010) when option /debug+ is used with /optimize.
Internal changes (may affect macros):
* Now using Hint instead of Fix() in array covariance check.
* Added RegisterParserAttribute.
Macro library changes:
* Modified macro async. Earlier it was applicable only to void methods, now it's like lazy.
* Refactored partial application for standard binary macro operators.
* Memoize macro now using double-checked locking when have no method parameters (don't have hash table)
Visual Studio Integration:
* Table formating support has been implemented.
* Fixed and improved goto definition for external types.
* Added navigation to interfaces defined in another project from same solution.
* Implemented collapsible multi-line comments.
Other stuff:
* PEG parser has been refactored. Trivial handlers is not necessary any more.
Fixed issues from tracker:
* #0544: Using base.foo() to call method from class higher in hierarchy than direct parent.
* #0841: Do not allow to cast array[T] to array[S], if T is not known to be a reference type.
* #0973: Yielding: don't always transform var->field.
* #1042: Some macros produce non first class funs/operators.
* #1063: Can't create aliased type.
* #1230: Compiler consumes available memory, then catches OutOfMemoryException.
* #1251: [VSIntegration] When using 'Implement Interface' feature, properties are implemented incorrectly.
* #1282: Incorrect error in contravariant interface.
* #1305: VS Integration highlights interface types with wrong color.
* #1308: Ncc cycling on serch .ctors.
1.0.0 Release Candidate, Dec 29 2010
Mono v2.6.x+ (or .NET v2.0 SP1) is required by this Nemerle release.
Compiler/language:
* 'for/while/foreach..else' construction has been changed to 'for/while/foreach..otherwise'.
* Added support of seting compiler stack size in megabytes (ncc switch '-stack-size').
* Enabled cil swith optimization for matching over enums. Added command line parameters for `CIL switch optimization': -min-switch-size-variants (-Oswv) and -min-switch-size-ordinals (-Oswo).
* Improved error message output for a mutable variable definition.
* MainParser has been extended with instance method 'ParseExpr': 'ParseExpr([NotNull] tokens : Token, stoppers : TokenStoppers) : PExpr * Token' which allow parse token sequence.
* Several fixes has been apply to support building under mono.
* Added support of a named constant in custom attributes.
* Fixed support of build under .NET 4.0 platform.
* Local function (and lambda) parameters are maked readable.
* Nullable comparison support has been improved.
* Implemented a 'Nullable' null matching.
* Added support for implicit match in foreach..otherwise.
* Added support of using \ and ` in macro operators.
* Adds bitwiseAnd, bitwiseOr and exclusiveOr operators for boolean type.
Internal changes (may affect macros):
* Solved the problem with macro order in .Net and Mono.
* The method 'TypeInfo.SuperType()' has been splitted to 'GetTypeArgumentsForSuperType()' and 'IsDerivedFrom()'.
* Nemerle.Data.Linq namespace is changed to Nemerle.Linq.
Library changes:
* Improved perfomance of NList methods.
* NList.ToList() now not extension method.
* Added Update method to Hashtable.
* Singleton pattern macro usability and verbosity has been improved.
* Added 'IterI' extension method to 'IEnumerable[T]'.
* ValueOption[T] struct has been added.
Macro library changes:
* Usability of 'Memoize' macro has been improved.
* Improved StructuralHashcode and StructuralEquality macros.
* Added support for 'is' operator and 'Expression<Action<...>>' for ToExpression macro at Nemerle.Linq library.
* Added tread safe Singleton pattern macro.
Visual Studio Integration:
* Improved code completion parsing engine.
* Added support of custom GoToInfo.
* Code formating has been improved.
* Nemerle Linq Macro now appears in VS add references.
Other stuff:
* C# parser project has benn added to PowerPack library.
* A tons of changes has been commited to achieve production quality of PEG and C# parsers.
* Added 'with' class initializer.
* Nemerle.Xml error reporting has been improved.
Fixed issues from tracker:
* #0352: Using inside namespace should open every namespace part suffixed by its name.
* #0422: Memoization macro Enhancement.
* #0637: Type load exn on MS.NET with generic type overrides.
* #0814: Cannot implement an interface twice with different type parameters.
* #0853: Nested polymoprhic types compile wrong.
* #0872: ICE: got ArgumentException (node already in the tree).
* #0911: Multi-level variants cause ICE.
* #0928: Nemerle.Collections.List.Remove throws NullReferenceException.
* #0947: Issue an error if type is declared inside variant option.
* #0991: Bug calling parent[T] static func (CheckSTV failed: cyclic type found).
* #1013: Variant nested type parsing bug.
* #1028: ICE: MType.SystemType for Intersection with overloaded functions.
* #1044: Wrong behaviour when adding new windows form to project.
* #1097: Attributes and enum value literal.
* #1067: ICE: assertion failed in file MType.n.
* #1101: Delayed typing fails in hard cases.
* #1120: Correctly handle usage of a contravariant type parameter in a constraint.
* #1135: ICE When type param constrain contain subtyped types.
* #1144: ICE in match case.
* #1145: Global symbols win over locals.
* #1212: ICE: type is null for 'a.
* #1227: ICE when overridden method have constraint which is deferent from constraint in method from base class.
* #1245: Accessor + interface bug.
* #1246: Illegal access to indexer in for loop.
* #1247: Code folding inside syntax macros.
* #1249: The foreach macro incorrect support of break & continue for multi-dimensional arrays.
* #1250: The foreach macro generate slow code.
* #1252: 'using..catch' incorrect catch block.
* #1256: VS Integration does not understand $(Nemerle) in MacroReference 's HintPath.
* #1257: Cand define type with members in macro code - NRE.
* #1260: "Start without debug" for Console application works wrong.
* #1261: Regexp match null check bug.
* #1262: Floating point comparisons have broken NaN handling.
* #1264: ICE during pattern matching with 'where' in the 1.0.0 Beta 2 build 9212 binary version.
* #1265: ICE in certain generic scenarios.
* #1267: ICE: nonfunction type?.
* #1268: Typer bug in local functions.
* #1270: Problem with outlining nested clases and modules.
* #1275: Integration stops working and consumes all available memory under some conditions.
* #1280: Static method in variant with contravariant constrain.
* #1281: Method constrain with contravariant interface.
* #1283: Implementing interface crashes compiler.
* #1284: Return value attribute.
* #1287: System.FieldAccessException when pattern access private field.
* #1290: Can't use typer.TypeExpr() in assembly level macro-attribute.
* #1294: ICE assertion ``False'' failed in Typer3.n.
* #1295: Autocompletion for variants.
* #1296: Project loading bug.
* #1297: ncc report "needed writable value" on event in DelayedTyping.
* #1299: Invalid comparison with nullables.
* #1300: ICE on Record applied to interface.
* #1302: Incorrect warning about uninitialized variable in method with out parameter.
1.0.0 Beta 2, Oct 06 2010
Mono v2.6.x+ (or .NET v2.0 SP1) is required by this Nemerle release.
Added PegGrammar.
Some bug fixes.
1.0.0 Beta 2, Jul 23 2010
Mono v2.6.x (or .NET v2.0 SP1) is required by this Nemerle release. Build under Mono is now possible by using Mono v2.7+.
Compiler/language:
* Code generation for <, >, <= and >= operators has been improved.
* Arguments for /target and /platform switches now case-insensitive.
* Add -check+/- option to enable (disable) integer overflow checking. By default overflow checking is enabled. Corresponding MSBuild project option is <CheckIntegerOverflow>.
* Changed encoding of compiler generated code. Now it has UTF8 encoding.
* Fixed "+" operator for Location of out of project files (when Location.FileIndex = 0).
* Now 'new' keyword can be used for override auto generated .ctor (for example by Record macro or variant options).
* Added pdb files for compilation.
* Allowed macros working with closures.
* Added support of comparison of nullable type values.
* Added PlatformTarget build parameter to Ncc.
Internal changes (may affect macros):
* The "UserData : Map[object, object]" has been added into TypeBuilder class.
* Parsed property (CcassMember.Property) redesigned. Now it has parsed* fields and mutable fields which can be changed by macros.
* Auto-properties expansion has been moved from parser into PropertyBuilder creation process. It allow prevent auto-properties expansion in macro-attributes which work in BeforeInheritance stage.
* Maded method parse_preprocessor in ncc/parsing/Lexer.n virtual.
* DelayedTyping.ResolveOverload() has been moved into Typer class (Typer-OverloadSelection.n).
* Custom attributes constructors now uses general overload resolution algorithm.
Library changes:
* The NLastN extension method has been added.
* Implemented Equals, GetHashCode & IComparable[Set[T]].
* The implicate conversion operator from Nullable[T] to option[T] has been added.
* Added AsOption() extension method to System.Nullable[T] structure.
* Added StartsWith and EndsWith extension methods which accept multiple arguments.
Macro library changes:
* RecordIgnore supported for constructors in Record macro.
* CompilationStart & TypeTreeBuildFinish event and UserData property has been added into ManagerClass.
* Added macro 'AnonymousClassOptions' for managing anonymous class visibility option (for NRails).
* Linq macro now support closure of local variables.
* Anonymous classes now generated with unique name.
* Added support for implicit conversion between public anonymous classes with same signature.
* New macro - "?.". See operators.n for details.
* Removed lambda macro.
* Added foreach..else macro. (Same as for..else in Python).
* Added for..else and while..else macros in addition to foreach..else.
* Support of index in foreach macro has been added.
Visual Studio Integration:
* Added XML comment generation to templates.
* The debug launch now show error message if it can't start process.
* Run without debugging improved, now work correctly and shows exit prompt. Added messages like in C# integration, auto save and auto build.
* Added support of Web Site project.
* Enabled trigger on typing '.'.
* Added template for ASP.NET MVC 2.0 application.
* Moved Linq to MacroReferences.
* Added support of aspx editor (intellisense, syntax coloring, hints and breakpoints).
* Added check to WinForms Designer form serialization.
* Added support of moving caret positioning to Event bodies when user double click on control (in WinForms designer).
Other stuff:
* Improved build process.
* Added computation expressions project, implements the same F# feature (http://en.wikibooks.org/wiki/F_Sharp_Programming/Computation_Expressions)
* Added build under .NET v4.0.
* Added Win32Resource property, so unmanaged resources can be embedded into assembly.
* Added Nemerle.XML project. It contains macro to support XML (like xml-literal and xml-pattern).
* Added PEG parser project. It implements a parser for parsing expression grammar (http://en.wikipedia.org/wiki/Parsing_expression_grammar)
* Added 'PowerPack' to installer: PEG parser, Computation Expressions and WPF dependency property macro.
Fixed issues from tracker:
* #492: Wrong overload selected when poly/non-poly versions are availble.
* #593: Addition of two ushorts gives int.
* #693: Literal values defined for class are not visible as such when defining other literal values for class.
* #718: Unable to pass literal to parameters of type short in Attributes.
* #812: ((x,y),z) => ... unsupported.
* #816: Type load exception.
* #862: Use nested polymorphic types to represent long tuples.
* #896: List's GetHashCode throws NullReferenceException if the list contains null.
* #897: List's Equals throws NullReferenceException if the list contains null.
* #1092: Bug in StructuralHashCode macro.
* #1093: Tuple arguments in interfaces cause compiler crash.
* #1106: Unable to find correct method to override in generic class when type parameter is tuple.
* #1143: $['a'..'f'] does not compile.
* #1158: Regexp match problem.
* #1188: Typing fails on ambiguity between overridden methods.
* #1191: ICE when trying to type ambigous interfaces.
* #1196: Disallow access modifiers on static constructors.
* #1198: DateTimePicker value assignment error (ambigous overloaded call of DateTime constructor).
* #1200: Wrong warning about attribute usage.
* #1203: Nemerle explicit interface.
* #1204: LinqToSQL error with WebApp and Optimization - true.
* #1206: ICE when try cast decimal value (from external member) to simple type.
* #1207: Type aliases work incorrectly when are evaluated as generic constraints.
* #1208: Incorrect down cast behaviour.
* #1209: Incorrect down cast behaviour if value give type by delayed typing.
* #1225: ICE: When quasi-quotation of module contains ..$().
* #1235: Preprocessor incorrectly interpret conditional directives.
* #1210: Lexer reports "Single-line comment or end-of-line expected" for #region directive if its description contains slash ( / ).
* #1215: Regex match generic type.
* #1216: Regexp match other assembly type.
* #1220: ICE nested enum.
* #1229: Compiler can't choose correct overload of implicit operator.
* #1231: Enumeration members from referenced assemblies always treated as Int32.
* #1233: ICE when type "where" pattern on type without super type.
* #1234: Expressions in $-strings not highlighted.
* #1235: Preprocessor incorrectly interpret conditional directives
* #1236: Allows macros working with closures.
* #1237: Nemerle.Logging macros throws errros in intellisense mode.
* #1238: Comparing two nullables.
* #1239: Start w/o debugging don't work when project path contains spaces.
* #1241: Decrement/Increment for char.
* #1244: Implementing abstract class.
* #1248: Add support of index in foreach macro.
1.0.0 Beta 1, Mar 12 2010
Mono 2.x (or .NET 2.0 SP1) is required by this Nemerle release. Build under Mono is temporary broken due to Mono bug (https://bugzilla.novell.com/show_bug.cgi?id=555464)
Compiler/language:
* Allowed type hints for wildcard lambda parameters.
* Implemented code access security. See http://msdn2.microsoft.com/en-us/library/33tceax8(VS.80).aspx
* Namespace can be opened using GlobalEnv.EnterIntoNamespace(). It need for create class in specific namespace.
* 'f' suffix for float literals.
* Improved error messages.
* Improved overload resolution. Now the compiler when resolve OverloadPossibility try resolve delayed typing objects nested in arguments expressions of call. For example it does possible use LINQ library which have many overloaded methods.
* Added support of pattern matching in parameters of macro "=>" (C# 3.0 lambda expression syntax). Now you can use syntax "((x, y)) => x * y" if you need get lambda with one parameter.
* Tuple now contains argument count.
* <%= ... %> syntax worked in .aspx pages of asp.net.
* Added support of polymorphic pattern matching on classes (like with variants). See match-on-polymorphic-class.n for details.
* Implemented using a extension methods as a functional values.
* Implemented LINQ support.
* Combined "-optimize" and "-debug+" compilier options.
* Added NCC switch -warnaserror+/-. Use it to treat warnings (except hints) as compilation errors.
Internal changes (may affect macros):
* Implement parsing of initializer expression of embedded (in property) field.
* Added public ctor to GlobalEnv. This ctor allow make GlobalEnv with additional keywords.
* Added ToString() implementation into TT.Parm class.
* Maked Typer.n() public.
* Implemented TExpt.MethodOf() and TExpt.CtorOf(). This expression help make references onto MethodInfo and ConstructorInfo (from macros).
* Added IsConstructor property into IMember interface and all it implementors.
* Added method IsCustomAttributeDefined() to TypeInfo.
* Added agrsCount field to MType.Fun which contains actual arguments count.
* Added property Typer.SkipExpressionTreeConvertion.
* Maked functions IsFunctional, LiteralConversionPossible and TryAddCastTo (of Typer) public.
* Added method IsWellTyped into ExprWalker class. This method return Yes if expr contains only well-typed subexprs, NotYet if contains delayed typing objects or not inferred types and Error if contains errors (TExpr.Error() objects). You can use it for determinate that all typing of subexpressions is done successfully.
* Added method FunParamsTypes into MType and TyVar types. This method extract from function type list of parameters types.
* Added method ToList into TyVar types. This method try convert type to list of type. If type is void result is empty list. If type is tuple result is tuple augments. Otherwise list contains one element - source type.
* Typer.TransformWhenAllTypesWillBeInfered renamed to TransformWhenAllTypesWouldBeInfered.
* Renamed IsJumpTarget to HasJumpTarget.
* Changed logic of resolve overloading (OverloadedOperator and find of nested delay typing).
* Maked location stack ThreadStatic variable (now you should use LocationStack.Top() to obtain current Location).
* Maked Location.GetFileIndex() thread safe.
* Changed type of "get" and "set" fields of ClassMember.Property to ClassMember.Function.
* Record macro now trims "_" from the beginning of constructor parameters.
* Changed the accessors of some external member infos and some of their members to public.
* TyVar has been renamed into TypeVar.
* MonoBindType/MonoBind has been replaced by BindFixedType.
* StaticTyVar has been replaced by StaticTypeVar.
* TyVarRef has been replaced by StaticTypeVarRef.
* TyVarEnv has been replaced by TypeVarEnv.
Library changes:
* Added Hashtable.Filter method.
* Nemerle extension methods now is usable from C# code.
* Removed System.Core.dll.
* Added Map2Lazy() and ZipLazy() extension methods.
* Added support of inheritance in Nemerle StringTemplate.
* Changed syntax of convertors in Nemerle StringTemplate. See string-template-1.n, for example.
* Added Exists() function into std lib for SCG.IEnumerable[T] type.
* Changed behavior of list[T].ForAll2(). Now it method returns false if lists have different length instead of System.ArgumentException throwing.
* Map2Array renamed to Map2ToArray and Zip renamed to ZipToArray.
* Added DebuggerNonUserCode attribute to NArray module.
* Added Count() extension method to NArray module.
* NStringBuilderExtensions module merged with StringBuilderEx.
* The TypeBulder.AstParts property is available now not only in IsIntelliSenseMode.
* The extension methods from NArray (narray.n) were moved into Nemerle.Collections and Nemerle.Collections.NoLinq namespaces (and corresponding n-files).
* System.Collections.List was renamed into NList.
* Used exact type parameters count for Nemerle.Core.list lockup.
* Moved all implementations from Nemerle.Collections.NoLinq.n to Nemerle.Collections.n.
* Renamed AsArray to NToArray to be more consistent with .net names.
Macro library changes:
* Improved NStringTemplate: added support of "template group type converters".
* Added explicit void type in macro loops.
* Added NotNull parameter to Record macro.
* Now it is possible to use RecordIgnore macro to add fields in a variant option. Fields marked by RecordIgnore macro not includes in default ctor and ignores in "tuple pattern".
* Implemented he LINQ support.
* Added SurroundWith macro.
* Added anonymous class implementation: def x = new (f1 = "blabla", f2 = 10).
* Record macro is now nicer with automatic properties. Also now it allows to define the modifier of the constructor generated.
* MType has been renamed into FixedType.
Visual Studio Integration changes:
* Added NemerleStudio (VS Shell isolated mode).
* Dropped VS2005 support.
* Added support of: "Show All Files" & "Exclude From Project/Include In Project".
* Improved intellisense:
- Supported member lookup when object is ambiguity (now we show union of members of all ambiguity objects).
- Fixed completion before separator token (like ',' or ')').
- Tries load assembly even if it not in reference list.
- Tries complete not well-written methods (which parameters not yet filled correctly).
- Added match braces support for files which not in the opened projects.
- Added navigation combos support for files which not in the opened projects.
* Added folding.
* Completely rewrited the compiler messages showing.
* Implemented Windows Forms designer.
* Moved compiler tasks (like parsing and typing) into background thread.
* Implemented completion in methods, properties & fields.
* Improved performance of editing global level code (i.e. types members, types and namespaces).
* Implemented smart tags.
Snippets & other stuff:
* Lot of build process improvements.
* Increased code coverage by tests.
* SVN version 1.5 (and future versions) support.
* Reflector addin updated.
* Added batch file for one-click build of installer.
* Increased stack size of some binaries for x64 support.
* The PEG parser implementation added.
* Added Asp.Net Web Project item templates.
* Added initial revision of codegenerators comparison.
* Rebuilded CCI assemblies to support .net 3.5
* Added binding for SharpDevelop 3.2.
Fixed issues from tracker:
* #1086: Allow custom attributes on interfaces.
* #1112: Visual Studio 2008 fails on 64 bit.
* #1119: VerificationException: Cannot take the address of an init-only field.
* #1125: Incorrect trate return macro in yield-methods.
* #1128: Typing fails on ambiguity between overloads if try put overloaded functon into argument.
* #964: Don't skip assigning default value to mutable vars.
* #1138: Nemerle source won't compile on windows with Turkish locale.
* #1032: Strange interface implementation behavior.
* #1102: IsBetterOverload bug.
* #1030: Incorrect line number in a warning message.
* #1133: Empty properties in interface definitions cause compiler to fail silently.
* #1154: Overload resolution not take into account type parameters constraints.
* #1153: Field of functional type does not compile in presence of extension method.
* #1071: Cannot assign to non-mutable field "First" when Nemerle.Utility is imported.
* #1072: Allow try inside expressions.
* #927: Text in thrown exception is inconsistent.
* #259: Cannot strore result of a try block.
* #936: Ncc (build 7471) builds itself, but it fails to build VS Integration.
* #1038: Returning tuple from block cases error.
* #1155: Don't allow try before base ctor call.
* #1156: It is impossible to define internal ctor for variant option.
* #1159: SVN Browser.
* #1066: MSBuild NCC task does not handle Win32Resource.
* #1067: ICE: assertion failed in file MType.n.
* #1162: Add /platform: switch for ncc.
* #1151: StringTemplate: it is impossible to use StringTemplateGroup macro on sealed types.
* #1152: SupportRelocation macro generates virtual method in sealed type.
* #1165: SetLastError in DllImport attribute doesn't work.
* #1171: Overload resolution breaks with generic methods+params.
* #1172: Invalid instantiation of generic.
* #1089: Cannot infer type for generic function.
* #795: ICE: can't compile Nemerle.Compiler.Utils project.
* #947: Issue an error if type is declared inside variant option.
* #883: Missing error concerning inaccessible class.
* #245: [return: ] custom attribute.
* #1181: Internal compiler error when deriving type of indexer.
* #1186: InternalsVisibleTo attribute doesn't work.
* #1065: ICE on bad nested generic typarams.
* #1183: Misleading warning for "is" pattern.
* #899: VS crashes if there is a cyclic inheritance.
* #1129: Unreachable skipped yield => nonlocal goto.
* #1091: Fall through end of method.
* #1121: Compiler emits invalid IL-code in debug mode.
* #1081: PEVerify: Backward branch constraints.
* #1193: It should be possible to pass an extension method as a functional value.
* #1194: Allow implicit concatenation of string literals only if there is a whitespace between them.
* #1176: Comment/uncomment selected invalid behavior.
...and also a lot of bugs not defined at tracker.
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**<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.
Jump to Line
Something went wrong with that request. Please try again.