New Programming Language ‘NIM’

Nim Programming Language

This release marks the completion of a very important change to the project: the official renaming from Nimrod to Nim. Version 0.10.2 contains many language changes, some of which may break your existing code. For your convenience, we added a new tool called nimfix that will help you convert your existing projects so that it works with the latest version of the compiler.

Progress towards version 1.0

Although Nim is still pre-1.0, we were able to keep the number of breaking changes to a minimum so far. Starting with version 1.0, we will not introduce any breaking changes between major release versions. One of Nim’s goals is to ensure that the compiler is as efficient as possible. Take a look at the latest benchmarks, which show that Nim is consistently near the top and already nearly as fast as C and C++. Recent developments, such as the new asyncdispatch module will allow you to write efficient web server applications using non-blocking code. Nim now also has a built-in thread pool for lightweight threading through the use of spawn.

The unpopular “T” and “P” prefixes on types have been deprecated. Nim also became more expressive by weakening the distinction between statements and epxressions. We also added a new and searchable forum, a new website, and our documentation generator docgen has seen major improvements.

What’s left to be done

The 1.0 release is actually very close. Apart from bug fixes, there are two major features missing or incomplete:

static[T] needs to be defined precisely and the bugs in the implementation need to be fixed.
Overloading of the assignment operator is required for some generic containers and needs to be implemented.
This means that fancy matrix libraries will finally start to work, which used to be a major point of pain in the language.

Outside of the language and the compiler itself many Nim tools have seen considerable improvements.

Babel the Nim package manager has been renamed to Nimble. Nimble’s purpose is the installation of packages containing libraries and/or applications written in Nim. Even though Nimble is still very young it already is very functional. It can install packages by name, it does so by accessing a packages repository which is hosted on a Github repo. Packages can also be installed via a Git repo URL or Mercurial repo URL. The package repository is searchable through Nimble. Anyone is free to add their own packages to the package repository by forking the nim-lang/packages repo and creating a pull request. Nimble is fully cross-platform and should be fully functional on all major operating systems. It is of course completely written in Nim.


Changes affecting backwards compatibility

The language has been renamed from Nimrod to Nim. The name of the compiler changed from nimrod to nim too.
system.fileHandle has been renamed to system.getFileHandle to prevent name conflicts with the new type FileHandle.
Comments are now not part of the AST anymore, as such you cannot use them in place of discard.
Large parts of the stdlib got rid of the T/P type prefixes. Instead most types now simply start with an uppercased letter. The so called “partial case sensitivity” rule is now active allowing for code like var foo: Foo in more contexts.
String case (or any non-ordinal case) statements without ‘else’ are deprecated.
Recursive tuple types are not allowed anymore. Use object instead.
The PEGS module returns nil instead of “” when an optional capture fails to match.
The re module returns nil instead of “” when an optional capture fails to match.
The “symmetric set difference” operator (-+-) never worked and has been removed.
defer is a keyword now.
func is a keyword now.
The using language feature now needs to be activated via the new {.experimental.} pragma that enables experimental language features.
Destructors are now officially experimental.
Standalone except and finally statements are deprecated now. The standalone finally can be replaced with defer, standalone except requires an explicit try.
Operators ending in > are considered as “arrow like” and have their own priority level and are right associative. This means that the => and -> operators from the future module work better.
Field names in tuples are now ignored for type comparisons. This allows for greater interoperability between different modules.
Statement lists are not converted to an implicit do block anymore. This means the confusing nnkDo nodes when working with macros are gone for good.
Language Additions

The new concurrency model has been implemented including locks sections, lock levels and object field guards.
The parallel statement has been implemented.
deepCopy has been added to the language.
The builtin procCall can be used to get super-like functionality for multi methods.
There is a new pragma {.experimental.} that enables experimental language features per module, or you can enable this features on a global level with the –experimental command line option.
Compiler Additions

The compiler now supports mixed Objective C / C++ / C code generation: The modules that use importCpp or importObjc are compiled to C++ or Objective C code, any other module is compiled to C code. This improves interoperability.
There is a new parallel statement for safe fork&join parallel computing.
guard and lock pragmas have been implemented to support safer concurrent programming.
The following procs are now available at compile-time:
math.sqrt, math.ln, math.log10, math.log2, math.exp, math.round,
math.arccos, math.arcsin, math.arctan, math.arctan2, math.cos, math.cosh,
math.hypot, math.sinh, math.sin, math.tan, math.tanh, math.pow,
math.trunc, math.floor, math.ceil, math.fmod,
os.getEnv, os.existsEnv, os.dirExists, os.fileExists,
Two backticks now produce a single backtick within an emit or asm statement.
There is a new tool, nimfix to help you in updating your code from Nimrod to Nim.
The compiler’s output has been prettified.
Library Additions

Added module fenv to control the handling of floating-point rounding and exceptions (overflow, division by zero, etc.).
system.setupForeignThreadGc can be used for better interaction with foreign libraries that create threads and run a Nim callback from these foreign threads.
List comprehensions have been implemented as a macro in the future module.
The new Async module (asyncnet) now supports SSL.
The smtp module now has an async implementation.
Added module asyncfile which implements asynchronous file reading and writing.
osproc.kill has been added.
asyncnet and asynchttpserver now support SO_REUSEADDR.

nil and NULL are now preserved between Nim and databases in the db_* modules.
Fixed issue with OS module in non-unicode mode on Windows.
Fixed issue with x.low (#1366).
Fixed tuple unpacking issue inside closure iterators (#1067).
Fixed ENDB compilation issues.
Many asynchttpserver fixes.
Macros can now keep global state across macro calls (#903).
osproc fixes on Windows.
osproc.terminate fixed.
Improvements to exception handling in async procedures. (#1487).
try now works at compile-time.
Fixes T = ref T to be an illegal recursive type.
Self imports are now disallowed.
Improved effect inference.
Fixes for the math module on Windows.
User defined pragmas will now work for generics that have been instantiated in different modules.
Fixed queue exhaustion bug.
Many, many more.
A brand new website including an improved forum is now live. All thanks go to Philip Witte and Dominik Picheta, Philip Witte for the design of the website (together with the logo) as well as the HTML and CSS code for his template, and Dominik Picheta for integrating Philip’s design with Nim’s forum. We’re sure you will agree that Philip’s design is beautiful.

Note: 0.9.6 is the last release of Nimrod. The language is being renamed to Nim. Nim slightly breaks compatibility.

This is a maintenance release. The upcoming 0.10.0 release has the new features and exciting developments.

Changes affecting backwards compatibility

spawn now uses an elaborate self-adapting thread pool and as such has been moved into its own module. So to use it, you now have to import threadpool.
The symbol binding rules in generics changed: bar in is now considered for implicit early binding.
c2nim moved into its own repository and is now a Babel package.
pas2nim moved into its own repository and is now a Babel package.
system.$ for floating point types now produces a human friendly string representation.
uri.TUrl as well as the parseurl module are now deprecated in favour of the new TUri type in the uri module.
The destructor pragma has been deprecated. Use the override pragma instead. The destructor’s name has to be destroy now.
lambda is not a keyword anymore.
system.defined has been split into system.defined and system.declared. You have to use –symbol to declare new conditional symbols that can be set via –define.
–threadanalysis:on is now the default. To make your program compile you can disable it but this is only a temporary solution as this option will disappear soon!
Compiler improvements

Multi method dispatching performance has been improved by a factor of 10x for pathological cases.
Language Additions

This version introduces the deprecated pragma statement that is used to handle the upcoming massive amount of symbol renames.
spawn can now wrap proc that has a return value. It then returns a data flow variable of the wrapped return type.
Library Additions

Added module cpuinfo.
Added module threadpool.
sequtils.distnct has been renamed to sequtils.deduplicate.
Added algorithm.reversed
Added uri.combine and uri.parseUri.
Some sockets procedures now support a SafeDisconn flag which causes them to handle disconnection errors and not raise them.
The Nimrod development community is proud to announce the release of version 0.9.4 of the Nimrod compiler and tools. Note: This release has to be considered beta quality! Lots of new features have been implemented but unfortunately some do not fullfill our quality standards yet.

Prebuilt binaries and instructions for building from source are available on the download page.

This release includes about 1400 changes in total including various bug fixes, new languages features and standard library additions and improvements. This release brings with it support for user-defined type classes, a brand new VM for executing Nimrod code at compile-time and new symbol binding rules for clean templates.

It also introduces support for the brand new Babel package manager which has itself seen its first release recently. Many of the wrappers that were present in the standard library have been moved to separate repositories and should now be installed using Babel.

Apart from that a new experimental Asynchronous IO API has been added via the asyncdispatch and asyncnet modules. The net and rawsockets modules have also been added and they will likely replace the sockets module in the next release. The Asynchronous IO API has been designed to take advantage of Linux’s epoll and Windows’ IOCP APIs, support for BSD’s kqueue has not been implemented yet but will be in the future. The Asynchronous IO API provides both a callback interface and an interface which allows you to write code as you would if you were writing synchronous code. The latter is done through the use of an await macro which behaves similar to C#’s await. The following is a very simple chat server demonstrating Nimrod’s new async capabilities.

import asyncnet, asyncdispatch

var clients: seq[PAsyncSocket] = @[]

proc processClient(client: PAsyncSocket) {.async.} =
  while true:
    let line = await client.recvLine()
    for c in clients:
      await c.send(line & “\c\L”)

proc serve() {.async.} =
  var server = newAsyncSocket()
  while true:
    let client = await server.accept()
    clients.add client

Note that this feature has been implemented with Nimrod’s macro system and so await and async are no keywords.

Syntactic sugar for anonymous procedures has also been introduced. It too has been implemented as a macro. The following shows some simple usage of the new syntax:

import future

var s = @[1, 2, 3, 4, 5]
echo( int) => x * 5))
A list of changes follows, for a comprehensive list of changes take a look here.

Library Additions

Added macros.genSym builtin for AST generation.
Added macros.newLit procs for easier AST generation.
Added module logging.
Added module asyncdispatch.
Added module asyncnet.
Added module net.
Added module rawsockets.
Added module selectors.
Added module asynchttpserver.
Added support for the new asynchronous IO in the httpclient module.
Added a Python-inspired future module that features upcoming additions to the system module.
Changes affecting backwards compatibility

The scoping rules for the if statement changed for better interaction with the new syntactic construct (;).
OSError family of procedures has been deprecated. Procedures with the same name but which take different parameters have been introduced. These procs now require an error code to be passed to them. This error code can be retrieved using the new OSLastError proc.
os.parentDir now returns “” if there is no parent dir.
In CGI scripts stacktraces are shown to the user only if cgi.setStackTraceStdout is used.
The symbol binding rules for clean templates changed: bind for any symbol that’s not a parameter is now the default. mixin can be used to require instantiation scope for a symbol.
quoteIfContainsWhite now escapes argument in such way that it can be safely passed to shell, instead of just adding double quotes.
macros.dumpTree and macros.dumpLisp have been made immediate, dumpTreeImm and dumpLispImm are now deprecated.
The nil statement has been deprecated, use an empty discard instead. now prunes sockets that are not ready from the list of sockets given to it.
The noStackFrame pragma has been renamed to asmNoStackFrame to ensure you only use it when you know what you’re doing.
Many of the wrappers that were present in the standard library have been moved to separate repositories and should now be installed using Babel.
Compiler Additions

The compiler can now warn about “uninitialized” variables. (There are no real uninitialized variables in Nimrod as they are initialized to binary zero). Activate via {.warning[Uninit]:on.}.
The compiler now enforces the not nil constraint.
The compiler now supports a codegenDecl pragma for even more control over the generated code.
The compiler now supports a computedGoto pragma to support very fast dispatching for interpreters and the like.
The old evaluation engine has been replaced by a proper register based virtual machine. This fixes numerous bugs for nimrod i and for macro evaluation.
–gc:none produces warnings when code uses the GC.
A union pragma for better C interoperability is now supported.
A packed pragma to control the memory packing/alignment of fields in an object.
Arrays can be annotated to be unchecked for easier low level manipulations of memory.
Support for the new Babel package manager.
Language Additions

Arrays can now be declared with a single integer literal N instead of a range; the range is then 0..N-1.
Added requiresInit pragma to enforce explicit initialization.
Exported templates are allowed to access hidden fields.
The using statement enables you to more easily author domain-specific languages and libraries providing OOP-like syntactic sugar.
Added the possibility to override various dot operators in order to handle calls to missing procs and reads from undeclared fields at compile-time.
The overload resolution now supports static[T] params that must be evaluable at compile-time.
Support for user-defined type classes has been added.
The command syntax is supported in a lot more contexts.
Anonymous iterators are now supported and iterators can capture variables of an outer proc.
The experimental strongSpaces parsing mode has been implemented.
You can annotate pointer types with regions for increased type safety.
Added support for the builtin spawn for easy thread pool usage.
Tools improvements

c2nim can deal with a subset of C++. Use the –cpp command line option to activate.
Nimrod has been featured as the cover story in the February 2014 issue of Dr. Dobb’s Journal.

Andreas Rumpf presented Nimrod: A New Approach to Metaprogramming at Strange Loop 2013. The video and slides of the talk are now available.

A brand new website is now live. All thanks go to Philip Witte and Dominik Picheta, Philip Witte for the design of the website (together with the logo) as well as the HTML and CSS code for his template, and Dominik Picheta for integrating Philip’s design with the nimweb utility. We’re sure you will agree that Philip’s design is beautiful.

We are pleased to announce that version 0.9.2 of the Nimrod compiler has been released. This release has attracted by far the most contributions in comparison to any other release.

This release brings with it many new features and bug fixes, a list of which can be seen later. One of the major new features is the effect system together with exception tracking which allows for checked exceptions and more, for further details check out the manual. Another major new feature is the introduction of statement list expressions, more details on these can be found here. The ability to exclude symbols from modules has also been implemented, this feature can be used like so: import module except symbol.

Thanks to all contributors!


The old GC never collected cycles correctly. Fixed but it can cause performance regressions. However you can deactivate the cycle collector with GC_disableMarkAndSweep and run it explicitly at an appropriate time or not at all. There is also a new GC you can activate with –gc:markAndSweep which does not have this problem but is slower in general and has no realtime guarantees.
cast for floating point types now does the bitcast as specified in the manual. This breaks code that erroneously uses cast to convert different floating point values.
SCGI module’s performance has been improved greatly, it will no longer block on many concurrent requests.
In total fixed over 70 github issues and merged over 60 pull requests.
Library Additions

There is a new experimental mark&sweep GC which can be faster (or much slower) than the default GC. Enable with –gc:markAndSweep.
Added system.onRaise to support a condition system.
Added system.locals that provides access to a proc’s locals.
Added macros.quote for AST quasi-quoting.
Added system.unsafeNew to support hacky variable length objects.
system.fields and system.fieldPairs support object too; they used to only support tuples.
Added system.CurrentSourcePath returning the full file-system path of the current source file.
The macros module now contains lots of useful helpers for building up abstract syntax trees.
Changes affecting backwards compatibility

shared is a keyword now.
Deprecated sockets.recvLine and asyncio.recvLine, added readLine instead.
The way indentation is handled in the parser changed significantly. However, this affects very little (if any) real world code.
The expression/statement unification has been implemented. Again this only affects edge cases and no known real world code.
Changed the async interface of the scgi module.
WideStrings are now garbage collected like other string types.
Compiler Additions

The doc2 command does not generate output for the whole project anymore. Use the new –project switch to enable this behaviour.
The compiler can now warn about shadowed local variables. However, this needs to be turned on explicitly via –warning[ShadowIdent]:on.
The compiler now supports almost every pragma in a push pragma.
Generic converters have been implemented.
Added a highly experimental noforward pragma enabling a special compilation mode that largely eliminates the need for forward declarations.
Language Additions

case expressions are now supported.
Table constructors now mimic more closely the syntax of the case statement.
Nimrod can now infer the return type of a proc from its body.
Added a mixin declaration to affect symbol binding rules in generics.
Exception tracking has been added and the doc2 command annotates possible exceptions for you.
User defined effects (“tags”) tracking has been added and the doc2 command annotates possible tags for you.
Types can be annotated with the new syntax not nil to explicitly state that nil is not allowed. However currently the compiler performs no advanced static checking for this; for now it’s merely for documentation purposes.
An export statement has been added to the language: It can be used for symbol forwarding so client modules don’t have to import a module’s dependencies explicitly.
Overloading based on ASTs has been implemented.
Generics are now supported for multi methods.
Objects can be initialized via an object constructor expression.
There is a new syntactic construct (;) unifying expressions and statements.
You can now use from module import nil if you want to import the module but want to enforce fully qualified access to every symbol in module.
Notes for the future

The scope rules of if statements will change in 0.9.4. This affects the =~ pegs/re templates.
The sockets module will become a low-level wrapper of OS-specific socket functions. All the high-level features of the current sockets module will be moved to a network module.

Unsigned integers have been added.
The integer type promotion rules changed.
The template and macro system evolved.
Closures have been implemented.
Term rewriting macros have been implemented.
First steps to unify expressions and statements have been taken.
Symbol lookup rules in generics have become stricter to catch more errors.

Fixed a bug where the compiler would “optimize away” valid constant parts of a string concatenation.
Fixed a bug concerning implicit type conversions in case statements.
Fixed a serious code generation bug that caused algorithm.sort to produce segmentation faults.
Fixed ambiguity in recvLine which meant that receiving \r\L was indistinguishable from disconnections.
Many more bugfixes, too many to list them all.
Library Additions

Added the (already existing) module htmlgen to the documentation.
Added the (already existing) module cookies to the documentation.
Added system.shallow that can be used to speed up string and sequence assignments.
Added system.eval that can execute an anonymous block of code at compile time as if was a macro.
Added system.staticExec and system.gorge for compile-time execution of external programs.
Added system.staticRead as a synonym for system.slurp.
Added macros.emit that can emit an arbitrary computed string as nimrod code during compilation.
Added strutils.parseEnum.
Added json.% constructor operator.
The stdlib can now be avoided to a point where C code generation for 16bit micro controllers is feasible.
Added module oids.
Added module endians.
Added a new OpenGL wrapper that supports OpenGL up to version 4.2.
Added a wrapper for libsvm.
Added a wrapper for mongodb.
Added terminal.isatty.
Added an overload for system.items that can be used to iterate over the values of an enum.
Added system.TInteger and system.TNumber type classes matching any of the corresponding types available in Nimrod.
Added system.clamp to limit a value within an interval [a, b].
Added strutils.continuesWith.
Added system.getStackTrace.
Added system.|| for parallel for loop support.
The GC supports (soft) realtime systems via GC_setMaxPause and GC_step procs.
The sockets module now supports ssl through the OpenSSL library, recvLine is now much more efficient thanks to the newly implemented sockets buffering.
The httpclient module now supports ssl/tls.
Added times.format as well as many other utility functions for managing time.
Added system.@ for converting an openarray to a seq (it used to only support fixed length arrays).
Added system.compiles which can be used to check whether a type supports some operation.
Added strutils.format, subexes.format which use the new varargs type.
Added module fsmonitor.
Changes affecting backwards compatibility

On Windows filenames and paths are supposed to be in UTF-8. The system, os, osproc and memfiles modules use the wide string versions of the WinAPI. Use the -d:useWinAnsi switch to revert back to the old behaviour which uses the Ansi string versions.
static, do, interface and mixin are now keywords.
Templates now participate in overloading resolution which can break code that uses templates in subtle ways. Use the new immediate pragma for templates to get a template of old behaviour.
There is now a proper distinction in the type system between expr and PNimrodNode which unfortunately breaks the old macro system.
pegs.@ has been renamed to pegs.!* and pegs.@@ has been renamed to pegs.!*\ as @ operators now have different precedence.
The type proc (without any params or return type) is now considered a type class matching all proc types. Use proc () to get the old meaning denoting a proc expecing no arguments and returing no value.
Deprecated system.GC_setStrategy.
re.findAll and pegs.findAll don’t return captures anymore but matching substrings.
RTTI and thus the marshall module don’t contain the proper field names of tuples anymore. This had to be changed as the old behaviour never produced consistent results.
Deprecated the ssl module.
Deprecated nimrod pretty as it never worked good enough and has some inherent problems.
The integer promotion rules changed; the compiler is now less picky in some situations and more picky in other situations: In particular implicit conversions from int to int32 are now forbidden.
system.byte is now an alias for uint8; it used to be an alias to int8.
bind expressions in templates are not properly supported anymore. Use the declarative bind statement instead.
The default calling convention for a procedural type is now closure, for procs it remains nimcall (which is compatible to closure). Activate the warning ImplicitClosure to make the compiler list the occurances of proc types which are affected.
The Nimrod type system now distinguishes openarray from varargs.
Templates are now hygienic. Use the dirty pragma to get the old behaviour.
Objects that have no ancestor are now implicitly final. Use the inheritable pragma to introduce new object roots apart from TObject.
Macros now receive parameters like templates do; use the callsite builtin to gain access to the invocation AST.
Symbol lookup rules in generics have become stricter to catch more errors.
Compiler Additions

Win64 is now an officially supported target.
The Nimrod compiler works on BSD again, but has some issues as os.getAppFilename and os.getAppDir cannot work reliably on BSD.
The compiler can detect and evaluate calls that can be evaluated at compile time for optimization purposes with the –implicitStatic command line option or pragma.
The compiler now generates marker procs that the GC can use instead of RTTI. This speeds up the GC quite a bit.
The compiler now includes a new advanced documentation generator via the doc2 command. This new generator uses all of the semantic passes of the compiler and can thus generate documentation for symbols hiding in macros.
The compiler now supports the dynlib pragma for variables.
The compiler now supports bycopy and byref pragmas that affect how objects/tuples are passed.
The embedded profiler became a stack trace profiler and has been documented.
Language Additions

Added explicit static sections for enforced compile time evaluation.
Added an alternative notation for lambdas with do.
addr is now treated like a prefix operator syntactically.
Added global pragma that can be used to introduce new global variables from within procs.
when expressions are now allowed just like if expressions.
The precedence for operators starting with @ is different now allowing for sigil-like operators.
Stand-alone finally and except blocks are now supported.
Macros and templates can now be invoked as pragmas.
The apostrophe in type suffixes for numerical literals is now optional.
Unsigned integer types have been added.
The integer promotion rules changed.
Nimrod now tracks proper intervals for range over some built-in operators.
In parameter lists a semicolon instead of a comma can be used to improve readability: proc divmod(a, b: int; resA, resB: var int).
A semicolon can now be used to have multiple simple statements on a single line: inc i; inc j.
bind supports overloaded symbols and operators.
A distinct type can now borrow from generic procs.
Added the pragmas gensym, inject and dirty for hygiene in templates.
Comments can be continued with a backslash continuation character so that comment pieces don’t have to align on the same column.
Enums can be annotated with pure so that their field names do not pollute the current scope.
A proc body can consist of an expression that has a type. This is rewritten to result = expression then.
Term rewriting macros (see trmacros) have been implemented but are still in alpha.
Version 0.8.14 has been released!


Fixed a serious memory corruption concerning message passing.
Fixed a serious bug concerning different instantiations of a generic proc.
Fixed a newly introduced bug where a wrong EIO exception was raised for the end of file for text files that do not end with a newline.
Bugfix c2nim, c2pas: the –out option has never worked properly.
Bugfix: forwarding of generic procs never worked.
Some more bugfixes for macros and compile-time evaluation.
The GC now takes into account interior pointers on the stack which may be introduced by aggressive C optimizers.
Nimrod’s native allocator/GC now works on PowerPC.
Lots of other bugfixes: Too many to list them all.
Changes affecting backwards compatibility

Removed deprecated os.AppendFileExt, os.executeShellCommand, os.iterOverEnvironment, os.pcDirectory, os.pcLinkToDirectory, os.SplitPath, os.extractDir, os.SplitFilename, os.extractFileTrunk, os.extractFileExt, osproc.executeProcess, osproc.executeCommand.
Removed deprecated parseopt.init, parseopt.getRestOfCommandLine.
Moved strutils.validEmailAddress to matchers.validEmailAddress.
The pointer dereference operator ^ has been removed, so that ^ can now be a user-defined operator.
implies is no keyword anymore.
The is operator is now the of operator.
The is operator is now used to check type equivalence in generic code.
The pure pragma for procs has been renamed to noStackFrame.
The threading API has been completely redesigned.
The unidecode module is now thread-safe and its interface has changed.
The bind expression is deprecated, use a bind declaration instead.
system.raiseHook is now split into system.localRaiseHook and system.globalRaiseHook to distinguish between thread local and global raise hooks.
Changed exception handling/error reporting for os.removeFile and os.removeDir.
The algorithm for searching and loading configuration files has been changed.
Operators now have diffent precedence rules: Assignment-like operators (like *=) are now special-cased.
The fields in TStream have been renamed to have an Impl suffix because they should not be used directly anymore. Wrapper procs have been created that should be used instead.
export is now a keyword.
assert is now implemented in pure Nimrod as a template; it’s easy to implement your own assertion templates with system.astToStr.
Language Additions

Added new is and of operators.
The built-in type void can be used to denote the absense of any type. This is useful in generic code.
Return types may be of the type var T to return an l-value.
The error pragma can now be used to mark symbols whose usage should trigger a compile-time error.
There is a new discardable pragma that can be used to mark a routine so that its result can be discarded implicitly.
Added a new noinit pragma to prevent automatic initialization to zero of variables.
Constants can now have the type seq.
There is a new user-definable syntactic construct a{i, …} that has no semantics yet for built-in types and so can be overloaded to your heart’s content.
bind (used for symbol binding in templates and generics) is now a declarative statement.
Nimrod now supports single assignment variables via the let statement.
Iterators named items and pairs are implicitly invoked when an explicit iterator is missing.
The slice assignment a[i..j] = b where a is a sequence or string now supports splicing.
Compiler Additions

The compiler can generate C++ code for easier interfacing with C++.
The compiler can generate Objective C code for easier interfacing with Objective C.
The new pragmas importcpp and importobjc make interfacing with C++ and Objective C somewhat easier.
Added a new pragma incompleteStruct to deal with incomplete C struct definitions.
Added a –nimcache:PATH configuration option for control over the output directory for generated code.
The –genScript option now produces different compilation scripts which do not contain absolute paths.
Added –cincludes:dir, –clibdir:lib configuration options for modifying the C compiler’s header/library search path in cross-platform way.
Added –clib:lib configuration option for specifying additional C libraries to be linked.
Added –mainmodule:file configuration options for specifying the main project file. This is intended to be used in project configuration files to allow commands like nimrod c or nimrod check to be executed anywhere within the project’s directory structure.
Added a –app:staticlib option for creating static libraries.
Added a –tlsEmulation:on|off switch for control over thread local storage emulation.
The compiler and standard library now support a taint mode. Input strings are declared with the TaintedString string type. If the taint mode is turned on it is a distinct string type which helps to detect input validation errors.
The compiler now supports the compilation cache via –symbolFiles:on. This potentially speeds up compilations by an order of magnitude, but is still highly experimental!
Added –import:file and –include:file configuration options for specifying modules that will be automatically imported/incluced.
nimrod i can now optionally be given a module to execute.
The compiler now performs a simple alias analysis to generate better code.
The compiler and ENDB now support watchpoints.
The compiler now supports proper compile time expressions of type bool for on|off switches in pragmas. In order to not break existing code, on and off are now aliases for true and false and declared in the system module.
The compiler finally supports closures. This is a preliminary implementation, which does not yet support nestings deeper than 1 level and still has many known bugs.
Library Additions

Added system.allocShared, system.allocShared0, system.deallocShared, system.reallocShared.
Slicing as implemented by the system module now supports splicing.
Added explicit channels for thread communication.
Added matchers module for email address etc. matching.
Added strutils.unindent, strutils.countLines, strutils.replaceWord.
Added system.slurp for easy resource embedding.
Added system.running for threads.
Added system.programResult.
Added xmltree.innerText.
Added os.isAbsolute, os.dynLibFormat, os.isRootDir, os.parentDirs.
Added parseutils.interpolatedFragments.
Added macros.treeRepr, macros.lispRepr, macros.dumpTree, macros.dumpLisp, macros.parseExpr, macros.parseStmt, macros.getAst.
Added locks core module for more flexible locking support.
Added irc module.
Added ftpclient module.
Added memfiles module.
Added subexes module.
Added critbits module.
Added asyncio module.
Added actors module.
Added algorithm module for generic sort, reverse etc. operations.
Added osproc.startCmd, osproc.execCmdEx.
The osproc module now uses posix_spawn instead of fork and exec on Posix systems. Define the symbol useFork to revert to the old implementation.
Added intsets.assign.
Added system.astToStr and system.rand, system.doAssert.
Added system.pairs for built-in types like arrays and strings.

Bugfix: httpclient correct passes the path starting with /.
Bugfixes for the htmlparser module.
Bugfix: pegs.find did not respect start parameter.
Bugfix: dialogs.ChooseFilesToOpen did not work if only one file is selected.
Bugfix: niminst: nimrod is not default dir for every project.
Bugfix: Multiple yield statements in iterators did not cause local vars to be copied.
Bugfix: The compiler does not emit very inaccurate floating point literals anymore.
Bugfix: Subclasses are taken into account for try except matching.
Bugfix: Generics and macros are more stable. There are still known bugs left though.
Bugfix: Generated type information for tuples was sometimes wrong, causing random crashes.
Lots of other bugfixes: Too many to list them all.
Changes affecting backwards compatibility

Operators starting with ^ are now right-associative and have the highest priority.
Deprecated os.getApplicationFilename: Use os.getAppFilename instead.
Deprecated os.getApplicationDir: Use os.getAppDir instead.
Deprecated system.copy: Use substr or string slicing instead.
Changed and documented how generalized string literals work: The syntax”abc” is now supported.
Changed the behaviour of strutils.%, ropes.% if both notations $# and $i are involved.
The pegs and re modules distinguish between replace and replacef operations.
The pointer dereference operation p^ is deprecated and might become ^p in later versions or be dropped entirely since it is rarely used. Use the new notation p[] in the rare cases where you need to dereference a pointer explicitly.
system.readFile does not return nil anymore but raises an EIO exception instead.
Unsound co-/contravariance for procvars has been removed.
Language Additions

Source code filters are now documented.
Added the linearScanEnd, unroll, shallow pragmas.
Added emit pragma for direct code generator control.
Case statement branches support constant sets for programming convenience.
Tuple unpacking is not enforced in for loops anymore.
The compiler now supports array, sequence and string slicing.
A field in an enum may be given an explicit string representation. This yields more maintainable code than using a constant array[TMyEnum, string] mapping.
Indices in array literals may be explicitly given, enhancing readability: [enumValueA: “a”, enumValueB: “b”].
Added thread support via the threads core module and the –threads:on command line switch.
The built-in iterators system.fields and system.fieldPairs can be used to iterate over any field of a tuple. With this mechanism operations like == and hash are lifted to tuples.
The slice .. is now a first-class operator, allowing code like: x in 1000..100_000.
Compiler Additions

The compiler supports IDEs via the new group of idetools command line options.
The interactive mode (REPL) has been improved and documented for the first time.
The compiler now might use hashing for string case statements depending on the number of string literals in the case statement.
Library Additions

Added lists module which contains generic linked lists.
Added sets module which contains generic hash sets.
Added tables module which contains generic hash tables.
Added queues module which contains generic sequence based queues.
Added intsets module which contains a specialized int set data type.
Added scgi module.
Added smtp module.
Added encodings module.
Added re.findAll, pegs.findAll.
Added os.findExe.
Added parseutils.parseUntil and parseutils.parseWhile.
Added strutils.align, strutils.tokenize, strutils.wordWrap.
Pegs support a captured search loop operator {@}.
Pegs support new built-ins: \letter, \upper, \lower, \title, \white.
Pegs support the new built-in \skip operation.
Pegs support the $ and ^ anchors.
Additional operations were added to the complex module.
Added strutils.formatFloat, strutils.formatBiggestFloat.
Added unary < for nice looking excluding upper bounds in ranges.
Added math.floor.
Added system.reset and a version of that returns a TFile and raises an exception in case of an error.
Added a wrapper for redis.
Added a wrapper for 0mq via the zmq module.
Added a wrapper for sphinx.
Added system.newStringOfCap.
Added system.raiseHook and system.outOfMemHook.
Added system.writeFile.
Added system.shallowCopy.
system.echo is guaranteed to be thread-safe.
Added prelude include file for scripting convenience.
Added typeinfo core module for access to runtime type information.
Added marshal module for JSON serialization.

Bugfix: Command line parsing on Windows and os.parseCmdLine now adheres to the same parsing rules as Microsoft's C/C++ startup code.
Bugfix: Passing a ref pointer to the untyped pointer type is invalid.
Bugfix: Updated keyval example.
Bugfix: system.splitChunk still contained code for debug output.
Bugfix: dialogs.ChooseFileToSave uses STOCK_SAVE instead of STOCK_OPEN for the GTK backend.
Bugfix: Various bugs concerning exception handling fixed.
Bugfix: low(somestring) crashed the compiler.
Bugfix: strutils.endsWith lacked range checking.
Bugfix: Better detection for AMD64 on Mac OS X.
Changes affecting backwards compatibility

Reversed parameter order for os.copyFile and os.moveFile!!!
Procs not marked as procvar cannot only be passed to a procvar anymore, unless they are used in the same module.
Deprecated times.getStartMilsecs: Use epochTime or cpuTime instead.
Removed system.OpenFile.
Removed system.CloseFile.
Removed strutils.replaceStr.
Removed strutils.deleteStr.
Removed strutils.splitLinesSeq.
Removed strutils.splitSeq.
Removed strutils.toString.
If a DLL cannot be loaded (via the dynlib pragma) EInvalidLibrary is not raised anymore. Instead system.quit() is called. This is because raising an exception requires heap allocations. However the memory manager might be contained in the DLL that failed to load.
The re module (and the pcre wrapper) now depend on the pcre dll.

The {.compile: "file.c".} pragma uses a CRC check to see if the file needs to be recompiled.
Added system.reopen.
Added system.getCurrentException.
Added system.appType.
Added system.compileOption.
Added times.epochTime and times.cpuTime.
Implemented explicit type arguments for generics.
Implemented {.size: sizeof(cint).} pragma for enum types. This is useful for interfacing with C.
Implemented {.pragma.} pragma for user defined pragmas.
Implemented {.extern.} pragma for better control of name mangling.
The importc and exportc pragmas support format strings: proc p{.exportc: "nim_$1".} exports p as nim_p. This is useful for user defined pragmas.
The standard library can be built as a DLL. Generating DLLs has been improved.
Added expat module.
Added json module.
Added support for a Tiny C backend. Currently this only works on Linux. You need to bootstrap with -d:tinyc to enable Tiny C support. Nimrod can then execute code directly via nimrod run myfile.

The Posix version of os.copyFile has better error handling.
Fixed bug #502670 (underscores in identifiers).
Fixed a bug in the parsexml module concerning the parsing of
Fixed a bug in the parsexml module concerning the parsing of enities like &ltXX.
system.write(f: TFile, s: string) now works even if s contains binary zeros.
Fixed a bug in os.setFilePermissions for Windows.
An overloadable symbol can now have the same name as an imported module.
Fixed a serious bug in strutils.cmpIgnoreCase.
Fixed unicode.toUTF8.
The compiler now rejects ‘\n’ (use “\n” instead).
times.getStartMilsecs() now works on Mac OS X.
Fixed a bug in pegs.match concerning start offsets.
Lots of other little bugfixes.

Added system.cstringArrayToSeq.
Added system.lines(f: TFile) iterator.
Added system.delete, system.del and system.insert for sequences.
Added system./ for int.
Exported system.newException template.
Added cgi.decodeData(data: string): tuple[key, value: string].
Added strutils.insertSep.
Added math.trunc.
Added ropes module.
Added sockets module.
Added browsers module.
Added httpserver module.
Added httpclient module.
Added parseutils module.
Added unidecode module.
Added xmldom module.
Added xmldomparser module.
Added xmltree module.
Added xmlparser module.
Added htmlparser module.
Added re module.
Added graphics module.
Added colors module.
Many wrappers now do not contain redundant name prefixes (like GTK_, lua). The old wrappers are still available in lib/oldwrappers. You can change your configuration file to use these.
Triple quoted strings allow for ” in more contexts.
“” within raw string literals stands for a single quotation mark.
Arguments to openArray parameters can be left out.
More extensive subscript operator overloading. (To be documented.)
The documentation generator supports the .. raw:: html directive.
The Pegs module supports back references via the notation $capture_index.
Changes affecting backwards compatibility

Overloading of the subscript operator only works if the type does not provide a built-in one.
The search order for libraries which is affected by the path option has been reversed, so that the project’s path is searched before the standard library’s path.
The compiler does not include a Pascal parser for bootstrapping purposes any more. Instead there is a pas2nim tool that contains the old functionality.
The procs os.copyFile and os.moveFile have been deprecated temporarily, so that the compiler warns about their usage. Use them with named arguments only, because the parameter order will change the next version!
atomic and let are now keywords.
The \w character class for pegs now includes the digits ‘0’..’9′.
Many wrappers now do not contain redundant name prefixes (like GTK_, lua) anymore.
Arguments to openArray parameters can be left out.
The version jump from 0.8.2 to 0.8.6 acknowledges the fact that all development of the compiler is now done in Nimrod.


The pragmas hint[X]:off and warning[X]:off now work.
Method call syntax for iterators works again (for x in lines.split()).
Fixed a typo in removeDir for POSIX that lead to an infinite recursion.
The compiler now checks that module filenames are valid identifiers.
Empty patterns for the dynlib pragma are now possible.
os.parseCmdLine returned wrong results for trailing whitespace.
Inconsequent tuple usage (using the same tuple with and without named fields) does not crash the code generator anymore.
A better error message is provided when the loading of a proc within a dynamic lib fails.

Added system.contains for open arrays.
The PEG module now supports the search loop operator @.
Grammar/parser: SAD|IND is allowed before any kind of closing bracket. This allows for more flexible source code formating.
The compiler now uses a bind table for symbol lookup within a bind context. (See manual.html#templates for details.)
discard “””my long comment””” is now optimized away.
New –floatChecks: on|off switches and pragmas for better debugging of floating point operations. (See manual.html#pre-defined-floating-point-types for details.)
The manual has been improved. (Many thanks to Philippe Lhoste!)
Changes affecting backwards compatibility

The compiler does not skip the linking step anymore even if no file has changed.
os.splitFile(“.xyz”) now returns (“”, “.xyz”, “”) instead of (“”, “”, “.xyz”). So filenames starting with a dot are handled differently.
strutils.split(s: string, seps: set[char]) never yields the empty string anymore. This behaviour is probably more appropriate for whitespace splitting.
The compiler now stops after the –version command line switch.
Removed support for enum inheritance in the parser; enum inheritance has never been documented anyway.
The msg field of system.E_base has now the type string, instead of cstring. This improves memory safety.
Nimrod version 0.6.0 has been released! This is the first version of the compiler that is able to compile itself!

Nim Programming Language


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s