Log Message:
Update to 0.18.0

Changelog:
0.18.0:
Changes affecting backwards compatibility
Breaking changes in the standard library

    The [] proc for strings now raises an IndexError exception when the \ 
specified slice is out of bounds. See issue #6223 for more details. You can use \ 
substr(str, start, finish) to get the old behaviour back, see this commit for an \ 
example.

    strutils.split and strutils.rsplit with an empty string and a separator now \ 
returns that empty string. See issue #4377.

    Arrays of char cannot be converted to cstring anymore, pointers to arrays of \ 
char can! This means $ for arrays can finally exist in system.nim and do the \ 
right thing. This means $myArrayOfChar changed its behaviour! Compile with \ 
-d:nimNoArrayToString to see where to fix your code.

    reExtended is no longer default for the re constructor in the re module.

    The behavior of $ has been changed for all standard library collections. The \ 
collection-to-string implementations now perform proper quoting and escaping of \ 
strings and chars.

    newAsyncSocket taking an AsyncFD now runs setBlocking(false) on the fd.

    mod and bitwise and do not produce range subtypes anymore. This turned out \ 
to be more harmful than helpful and the language is simpler without this special \ 
typing rule.

    formatFloat/formatBiggestFloat now support formatting floats with zero \ 
precision digits. The previous precision = 0 behavior (default formatting) is \ 
now available via precision = -1.
    Moved from stdlib into Nimble packages:
        basic2d deprecated: use glm, arraymancer, neo, or another package instead
        basic3d deprecated: use glm, arraymancer, neo, or another package instead
        gentabs
        libuv
        polynumeric
        pdcurses
        romans
        libsvm
        joyent_http_parser

    Proc toCountTable now produces a CountTable with values correspoding to the \ 
number of occurrences of the key in the input. It used to produce a table with \ 
all values set to 1.

    Counting occurrences in a sequence used to be:

    let mySeq = @[1, 2, 1, 3, 1, 4]
    var myCounter = initCountTable[int]()

    for item in mySeq:
      myCounter.inc item

    Now, you can simply do:

    let
      mySeq = @[1, 2, 1, 3, 1, 4]
      myCounter = mySeq.toCountTable()

    If you use --dynlibOverride:ssl with OpenSSL 1.0.x, you now have to define \ 
openssl10 symbol (-d:openssl10). By default OpenSSL 1.1.x is assumed.

    newNativeSocket is now named createNativeSocket.

    newAsyncNativeSocket is now named createAsyncNativeSocket and it no longer \ 
raises an OS error but returns an osInvalidSocket when creation fails.

    The securehash module is now deprecated. Instead import std / sha1.
    The readPasswordFromStdin proc has been moved from the rdstdin to the \ 
terminal module, thus it does not depend on linenoise anymore.

Breaking changes in the compiler

    \n is now only the single line feed character like in most other programming \ 
languages. The new platform specific newline escape sequence is written as \p. \ 
This change only affects the Windows platform.

    The overloading rules changed slightly so that constrained generics are \ 
preferred over unconstrained generics. (Bug #6526)

    We changed how array accesses “from backwards” like a[^1] or a[0..^1] \ 
are implemented. These are now implemented purely in system.nim without compiler \ 
support. There is a new “heterogenous” slice type system.HSlice that takes 2 \ 
generic parameters which can be BackwardsIndex indices. BackwardsIndex is \ 
produced by system.^. This means if you overload [] or []= you need to ensure \ 
they also work with system.BackwardsIndex (if applicable for the accessors).

    The parsing rules of if expressions were changed so that multiple statements \ 
are allowed in the branches. We found few code examples that now fail because of \ 
this change, but here is one:

    t[ti] = if exp_negative: '-' else: '+'; inc(ti)

    This now needs to be written as:

    t[ti] = (if exp_negative: '-' else: '+'); inc(ti)

    The experimental overloading of the dot . operators now take an untyped \ 
parameter as the field name, it used to be a static[string]. You can use when \ 
defined(nimNewDot) to make your code work with both old and new Nim versions. \ 
See special-operators for more information.

    yield (or await which is mapped to yield) never worked reliably in an array, \ 
seq or object constructor and is now prevented at compile-time.

Library additions

    Added sequtils.mapLiterals for easier construction of array and tuple literals.

    Added system.runnableExamples to make examples in Nim’s documentation \ 
easier to write and test. The examples are tested as the last step of nim doc.

    Implemented getIoHandler proc in the asyncdispatch module that allows you to \ 
retrieve the underlying IO Completion Port or Selector[AsyncData] object in the \ 
specified dispatcher.

    For string formatting / interpolation a new module called strformat has been \ 
added to the stdlib.

    The ReadyKey type in the selectors module now contains an errorCode field to \ 
help distinguish between Event.Error events.

    Implemented an accept proc that works on a SocketHandle in nativesockets.

    Added algorithm.rotateLeft.

    Added typetraits.$ as an alias for typetraits.name.

    Added system.getStackTraceEntries that allows you to access the stack trace \ 
in a structured manner without string parsing.

    Added parseutils.parseSaturatedNatural.

    Added macros.unpackVarargs.

    Added support for asynchronous programming for the JavaScript backend using \ 
the asyncjs module.

    Added true color support for some terminals. Example:

    import colors, terminal

    const Nim = "Efficient and expressive programming."

    var
      fg = colYellow
      bg = colBlue
      int = 1.0

    enableTrueColors()

    for i in 1..15:
      styledEcho bgColor, bg, fgColor, fg, Nim, resetStyle
      int -= 0.01
      fg = intensity(fg, int)

    setForegroundColor colRed
    setBackgroundColor colGreen
    styledEcho "Red on Green.", resetStyle

Library changes

    echo now works with strings that contain \0 (the binary zero is not shown) \ 
and nil strings are equal to empty strings.

    JSON: Deprecated getBVal, getFNum, and getNum in favour of getBool, \ 
getFloat, getBiggestInt. A new getInt procedure was also added.

    rationals.toRational now uses an algorithm based on continued fractions. \ 
This means its results are more precise and it can’t run into an infinite loop \ 
anymore.

    os.getEnv now takes an optional default parameter that tells getEnv what to \ 
return if the environment variable does not exist.

    The random procs in random.nim have all been deprecated. Instead use the new \ 
rand procs. The module now exports the state of the random number generator as \ 
type Rand so multiple threads can easily use their own random number generators \ 
that do not require locking. For more information about this rename see issue \ 
#6934

    writeStackTrace is now proclaimed to have no IO effect (even though it does) \ 
so that it is more useful for debugging purposes.

    db_mysql module: DbConn is now a distinct type that doesn’t expose the \ 
details of the underlying PMySQL type.

    parseopt2 is now deprecated, use parseopt instead.

Language additions

    It is now possible to forward declare object types so that mutually \ 
recursive types can be created across module boundaries. See package level \ 
objects for more information.

    Added support for casting between integers of same bitsize in VM (compile \ 
time and nimscript). This allows to, among other things, reinterpret signed \ 
integers as unsigned.

    Custom pragmas are now supported using pragma pragma, please see language \ 
manual for details.

    Standard library modules can now also be imported via the std \ 
pseudo-directory. This is useful in order to distinguish between standard \ 
library and nimble package imports:

    import std / [strutils, os, osproc]
    import someNimblePackage / [strutils, os]

Language changes

    The unary < is now deprecated, for .. < use ..< for other usages \ 
use the pred proc.

    Bodies of for loops now get their own scope:

    # now compiles:
    for i in 0..4:
      let i = i + 1
      echo i

    To make Nim even more robust the system iterators .. and countup now only \ 
accept a single generic type T. This means the following code doesn’t die with \ 
an “out of range” error anymore:

    var b = 5.Natural
    var a = -5
    for i in a..b:
      echo i

    atomic and generic are no longer keywords in Nim. generic used to be an \ 
alias for concept, atomic was not used for anything.

    The memory manager now uses a variant of the TLSF algorithm that has much \ 
better memory fragmentation behaviour. According to http://www.gii.upv.es/tlsf/ \ 
the maximum fragmentation measured is lower than 25%. As a nice bonus alloc and \ 
dealloc became O(1) operations.

    The compiler is now more consistent in its treatment of ambiguous symbols: \ 
Types that shadow procs and vice versa are marked as ambiguous (bug #6693).

    codegenDecl pragma now works for the JavaScript backend. It returns an empty \ 
string for function return type placeholders.

    Extra semantic checks for procs with noreturn pragma: return type is not \ 
allowed, statements after call to noreturn procs are no longer allowed.
    Noreturn proc calls and raising exceptions branches are now skipped during \ 
common type deduction in if and case expressions. The following code snippets \ 
now compile:

    import strutils
    let str = "Y"
    let a = case str:
      of "Y": true
      of "N": false
      else: raise newException(ValueError, "Invalid boolean")
    let b = case str:
      of nil, "": raise newException(ValueError, "Invalid \ 
boolean")
      elif str.startsWith("Y"): true
      elif str.startsWith("N"): false
      else: false
    let c = if str == "Y": true
      elif str == "N": false
      else:
        echo "invalid bool"
        quit("this is the end")

    Pragmas now support call syntax, for example: {.exportc"myname".} \ 
and {.exportc("myname").}

    The deprecated pragma now supports a user-definable warning message for procs.

    proc bar {.deprecated: "use foo instead".} =
      return

    bar()

Tool changes

    The nim doc command is now an alias for nim doc2, the second version of the \ 
documentation generator. The old version 1 can still be accessed via the new nim \ 
doc0 command.

    Nim’s rst2html command now supports the testing of code snippets via an \ 
RST extension that we called :test:::

    .. code-block:: nim
        :test:
      # shows how the 'if' statement works
      if true: echo "yes"

0.17.0:
Changes affecting backwards compatibility

    There are now two different HTTP response types, Response and AsyncResponse. \ 
AsyncResponse’s body accessor returns a Future[string]!

    Due to this change you may need to add another await in your code.
    httpclient.request now respects the maxRedirects option. Previously \ 
redirects were handled only by get and post procs.
    The IO routines now raise EOFError for the “end of file” condition. \ 
EOFError is a subtype of IOError and so it’s easier to distinguish between \ 
“error during read” and “error due to EOF”.
    A hash procedure has been added for cstring type in hashes module. \ 
Previously, hash of a cstring would be calculated as a hash of the pointer. Now \ 
the hash is calculated from the contents of the string, assuming cstring is a \ 
null-terminated string. Equal string and cstring values produce an equal hash \ 
value.
    Macros accepting varargs arguments will now receive a node having the \ 
nkArgList node kind. Previous code expecting the node kind to be nkBracket may \ 
have to be updated.
    memfiles.open now closes file handles/fds by default. Passing \ 
allowRemap=true to memfiles.open recovers the old behavior. The old behavior is \ 
only needed to call mapMem on the resulting MemFile.
    posix.nim: For better C++ interop the field sa_sigaction*: proc (x: cint, y: \ 
var SigInfo, z: pointer) {.noconv.} was changed to sa_sigaction*: proc (x: cint, \ 
y: ptr SigInfo, z: pointer) {.noconv.}.
    The compiler doesn’t infer effects for .base methods anymore. This means \ 
you need to annotate them with .gcsafe or similar to clearly declare upfront \ 
every implementation needs to fullfill these contracts.
    system.getAst templateCall(x, y) now typechecks the templateCall properly. \ 
You need to patch your code accordingly.
    macros.getType and macros.getTypeImpl for an enum will now return an AST \ 
that is the same as what is used to define an enum. Previously the AST returned \ 
had a repeated EnumTy node and was missing the initial pragma node (which is \ 
currently empty for an enum).
    macros.getTypeImpl now correctly returns the implementation for a symbol of \ 
type tyGenericBody.
    If the dispatcher parameter’s value used in multi method is nil, a \ 
NilError exception is raised. The old behavior was that the method would be a \ 
nop then.
    posix.nim: the family of ntohs procs now takes unsigned integers instead of \ 
signed integers.
    In Nim identifiers en-dash (Unicode point U+2013) is not an alias for the \ 
underscore anymore. Use underscores instead.
    When the requiresInit pragma is applied to a record type, future versions of \ 
Nim will also require you to initialize all the fields of the type during object \ 
construction. For now, only a warning will be produced.
    The Object construction syntax now performs a number of additional safety \ 
checks. When fields within case objects are initialiazed, the compiler will now \ 
demand that the respective discriminator field has a matching known compile-time \ 
value.
    On posix, the results of waitForExit, peekExitCode, execCmd will return 128 \ 
+ signal number if the application terminates via signal.
    ospaths.getConfigDir now conforms to the XDG Base Directory specification on \ 
non-Windows OSs. It returns the value of the XDG_CONFIG_DIR environment variable \ 
if it is set, and returns the default configuration directory, “~/.config/”, \ 
otherwise.
    Renamed the line info node parameter for newNimNode procedure.

    The parsing rules of do changed.

      foo bar do:
        baz

    Used to be parsed as:

      foo(bar(do:
        baz))

    Now it is parsed as:

      foo(bar, do:
        baz)

Library Additions

    Added system.onThreadDestruction.

    Added dial procedure to networking modules: net, asyncdispatch, asyncnet. It \ 
merges socket creation, address resolution, and connection into single step. \ 
When using dial, you don’t have to worry about the IPv4 vs IPv6 problem. \ 
httpclient now supports IPv6.

    Added to macro which allows JSON to be unmarshalled into a type.

      import json

      type
        Person = object
          name: string
          age: int

      let data = """
        {
          "name": "Amy",
          "age": 4
        }
      """

      let node = parseJson(data)
      let obj = node.to(Person)
      echo(obj)

Tool Additions

    The finish tool can now download MingW for you should it not find a working \ 
MingW installation.

Compiler Additions

    The name mangling rules used by the C code generator changed. Most of the \ 
time local variables and parameters are not mangled at all anymore. This \ 
improves the debugging experience.
    The compiler produces explicit name mangling files when --debugger:native is \ 
enabled. Debuggers can read these .ndi files in order to improve debugging Nim \ 
code.

Language Additions

    The try statement’s except branches now support the binding of a caught \ 
exception to a variable:

        try:
          raise newException(Exception, "Hello World")
        except Exception as exc:
          echo(exc.msg)

    This replaces the getCurrentException and getCurrentExceptionMsg() \ 
procedures, although these procedures will remain in the stdlib for the \ 
foreseeable future. This new language feature is actually implemented using \ 
these procedures.

    In the near future we will be converting all exception types to refs to \ 
remove the need for the newException template.
    A new pragma .used can be used for symbols to prevent the “declared but \ 
not used” warning. More details can be found here.

    The popular “colon block of statements” syntax is now also supported for \ 
let and var statements and assignments:

      template ve(value, effect): untyped =
        effect
        value

      let x = ve(4):
        echo "welcome to Nim!"

    This is particularly useful for DSLs that help in tree construction.

Language changes

    The .procvar annotation is not required anymore. That doesn’t mean you can \ 
pass system.$ to map just yet though.