Change Log: 2.072.0

Comma expressions have proven to be a frequent source of confusion, and bugs - see here for examples.

Using the result of a comma expression will now trigger a deprecation message.

Example:

void main () {
  // OK, result of increment not directly used
  for (int i, j; i != 3; i++, j++) {...}

  auto r1 = getRange!int, r2 = getRange!int;
  // OK
  for (; !r1.empty && !r2.empty; r1.popFront, r2.popFront) {...}
  // Deprecated - the loop condition is always used
  for (; !r1.empty, !r2.empty; r1.popFront, r2.popFront) {...}

  MyContainerClass mc;
  // OK - expression statement, result not used
  if (!mc)
    (mc = new MyContainerClass), mc.append(new Entry);

  int i;
  // Deprecated
  mc = (i++, new MyContainerClass);
}

Implicit catch statement are catch statement without type specified. They default to catching Throwable, which is something that should always be explicit.

Example:

int[] arr = new int[](10);
// This will throw a RangeError
try { arr[42]++; }
catch { writeln("An error was caught and ignored"); }
// The previous line is equivalent to:
// catch (Throwable) { writeln("An error was caught and ignored"); }

Implicit concatenation of string literal is a very early feature that is now supplanted by the concatenation operator ('~'), the later being more explicit.

It could result in hard to spot bug, where one missed a comma in an array expression:

void foo ()
{
  string[] arr = [ "Hello", "buggy" "World" ];
  assert(arr.length == 3); // Fail, the length of the array is 2 and the content is [ "Hello", "buggyWorld" ]
}

It is now allowed to have fields with postblits (this(this)), destructors (~this()), or invariants (invariant()) in unions. Actually destructing or blitting the correct field is the duty of the programmer.

Example:

struct S { this(this) {} ~this() {} }
union U
{
    int var;
    S s;
}

unittest
{
    U u; // won't call s.~this when u goes out of scope
    u = U(); // only copies the memory, use fieldwise assignment instead
    u.s = S(); // works like normal struct assignment
    destroy(u.s); // destroy currently used field
}

Example:

version (D_LP64)
    enum n = 8;
else
    enum n = 4;
align (n) struct Data
{
align (n == 8 ? 2 : 1):
    ubyte[3] buffer;
    int flags;
}

version (D_LP64)
    static assert(Data.flags.offsetof == 4);
else
    static assert(Data.flags.offsetof == 3);

The scope storage class is now ignored for copied value parameters that don't have any indirections.

Example:

import std.traits;
void valueParam(scope int param);
static assert(ParameterStorageClassTuple!valueParam[0] == ParameterStorageClass.none);
void scopeParam(scope int* param);
static assert(ParameterStorageClassTuple!scopeParam[0] == ParameterStorageClass.scope_);

The compiler has been updated to use native thread local storage (TLS) on OS X when compiling for 64 bit. This means that it's possible to to link with C/C++ TLS variables. This change is an ABI breaking change and requires recompiling libraries.

The minimum required version of running the compiler and any produced binary is now Mac OS X Lion (10.7).

Xcode 7.3 has a bug causing linker errors for some TLS variables. Xcode 7.3.1 fixes this bug. Any version older than 7.3 works as well.

Example:

module lib;
template ExpensiveApiImpl(int ver)
{
    ...
    void func() {}
    pragma(msg, "instantiated ExpensiveApiImpl ", ver);
}
alias api1 = ExpensiveApiImpl!(1);
alias api2 = ExpensiveApiImpl!(2);

import lib;
void main()
{
    // OK, prints "instantiated ExpensiveApiImpl 1"
    api1.func();

    // Don't print "instantiated ExpensiveApiImpl 2", because
    // the alias name 'api2' is not used.
}

The __FILE_FULL_PATH__ special keyword is replaced by the absolute path of the current source file by the compiler.

Example:

import std.stdio;
import std.path;
import std.file;
void main()
{
    writeln("The main source file lives here: ", __FILE_FULL_PATH__);
    writeln("The contents are:");
    foreach(line; File(__FILE_FULL_PATH__, "r").byLine) {
        writeln(line);
    }
    writeln();
    writeln("Other files in the same directory are:");
    foreach(entry; dirEntries(__FILE_FULL_PATH__.dirName, SpanMode.shallow)) {
        writefln("  - %s", entry.name);
    }
}

Shows errors from speculative compiles such as:

void foo(int i)
{
    int p;
    bool b = __traits(compiles, { p = &i; });
}

that are normally not shown:

(spec:1) test.d(13): Error: cannot implicitly convert expression (& i) of type int* to int

The number after spec: is the nesting of the speculative compiles.

This is a step towards removal of TypeInfo.init, which is necessary to resolve a name clash with the type property init.

Use TypeInfo.initializer instead.

When module cycles are detected, the default behavior is to print the cycle, and abort execution. However, in many cases, the cycles are not harmful. With the new --DRT-oncycle switch, you can effect a different behavior when cycles are detected:

--DRT-oncycle=abort

This is the default behavior, and will abort, printing the cycle to stderr when the first cycle is detected

--DRT-oncycle=print

Print all cycles that are detected to stderr, but do not halt execution. Order of initialization is arbitrarily chosen based on the order the modules are in the binary

--DRT-oncycle=ignore

Do not print anything, and do not halt execution. Order of initialization is arbitrarily chosen based on the order the modules are in the binary

extern(C) __gshared string[] rt_options = [ "oncycle=ignore" ];

std.digest.murmurhash has been added. MurmurHash is a non-cryptographic hash function suitable for general hash-based lookup. It is optimized for x86 architectures.

// Computing the 32-bits hash value of an int array using the convenient digest template.
import std.digest.murmurhash;

ubyte[4] hashed = digest!MurmurHash3_32_opt32([1, 2, 3, 4]);

Previously, Posix systems would attempt to close every file descriptor from 3 to the maximum file descriptor number if inheritFDs was not specified with spawnProcess, pipeProcess, etc. std.process now uses poll() to determine which descriptors need closing.

std.algorithm.iteration.cumulativeFold returns the successive reduced values of an input range.

assert([1, 2, 3, 4, 5].cumulativeFold!((a, b) => a + b).array == [1, 3, 6, 10, 15]);
assert([1, 2, 3].cumulativeFold!((a, b) => a + b)(100).array == [101, 103, 106]);

std.range.padLeft and std.range.padRight are functions for padding ranges to a specified length using the given element.

import std.range;
import std.algorithm.comparison;

assert([1, 2, 3, 4, 5].padLeft(0, 7).equal([0, 0, 1, 2, 3, 4, 5]));

assert("Hello World!".padRight('!', 15).equal("Hello World!!!!"));

import std.regex;
// multi-pattern regex
auto multi = regex([`\d+,\d+`,`(a-z]+):(\d+)`]);
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 2);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 1);
assert(m.front[1] == "12");

import std.regex;
import std.algorithm.comparison : equal;

auto pattern = regex(`([\.,])`);
assert("2003.04.05"
    .splitter!(No.keepSeparators)(pattern)
    .equal(["2003", "04", "05"]));
assert("2003.04.05"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal(["2003", ".", "04", ".", "05"]));

std.numeric.findLocalMin finds a real minimum of a real function f(x) via bracketing.

import std.numeric, std.math;

auto ret = findLocalMin((double x) => (x-4)^^2, -1e7, 1e7);

assert(ret.x.approxEqual(4.0));
assert(ret.y.approxEqual(0.0));

ptr property allows to access Slice's underlaying pointer or range. Please refer to std.experimental.ndslice.slice.Slice's internal binary epresentation before using the property. ptr property is used in Mir for sparse tensors. ndslice developer mirror in Mir will be removed as soon as LDC (LLVM D compiler) supports D version 2.072.

Public constructor for Slice was added to support std.experimental.ndslice integration with other languages and libraries such as Julia language and NumPy library.

import std.experimental.ndslice;

// hash is the same for allocated data and generated data
auto a = iotaSlice(3, 7);
auto b = iotaSlice(3, 7).slice;

assert(a.toHash == b.toHash);

These utility functions have been added to std.experimental.ndslice:

• std.experimental.ndslice.slice.makeNdarray,
• std.experimental.ndslice.slice.makeSlice,
• std.experimental.ndslice.slice.makeUninitializedSlice,
• std.experimental.ndslice.slice.ndarray,
• std.experimental.ndslice.slice.shape,
• std.experimental.ndslice.slice.slice,
• std.experimental.ndslice.slice.uninitializedSlice.

Example: Transposing common 2D array using ndslice

import std.experimental.ndslice;

auto ar = [[0, 1, 2], [3, 4, 5]];

auto sh = ar.shape;         // [2, 3] type of size_t[2]
auto sl = slice!int(sh);    // allocates slice with corresponding shape
sl[] = ar;                  // fills sl with values from ar
ar = sl.transposed.ndarray; // allocates common 2D array

assert(ar == [[0, 3], [1, 4], [2, 5]]);

import std.experimental.ndslice;

auto matrix = slice!double([2, 2], 0);
auto stringMatrixView = matrix.as!string;
assert(stringMatrixView ==
        [["0", "0"],
         ["0", "0"]]);

matrix.diagonal[] = 1;
assert(stringMatrixView ==
        [["1", "0"],
         ["0", "1"]]);

std.experimental.ndslice.selection.iotaSlice is the fastest possible Slice.

import std.experimental.ndslice;

auto sl = iotaSlice([2, 3], 10);

assert(sl.transposed == [[10, 13],
                         [11, 14],
                         [12, 15]]);

import std.experimental.ndslice;

auto slice = indexSlice(2, 3);

assert(slice == [[[0, 0], [0, 1], [0, 2]],
                 [[1, 0], [1, 1], [1, 2]]]);

import std.experimental.ndslice;

auto sl = iotaSlice(3).repeatSlice(4);
assert(sl == [[0, 1, 2],
              [0, 1, 2],
              [0, 1, 2],
              [0, 1, 2]]);

auto m = 4.repeatSlice(2, 3);
assert(m == [[4, 4, 4],
             [4, 4, 4]]);

import std.experimental.ndslice;

auto s = iotaSlice(2, 3).mapSlice!(a => a * a);
assert(s == [[ 0,  1,  4],
             [ 9, 16, 25]]);

import std.experimental.ndslice;

auto sl = iotaSlice(3, 4);

assert(sl[2, 3] == 11); // D & C index order
assert(sl(3, 2) == 11); // Math & Fortran index order

std.algorithm.mutation.swapAt allows to swap elements of a RandomAccessRange by their indices.

std.range.iota's .length property is now always returned as size_t. This means if you are on a 32-bit CPU and you are using iota to iterate 64-bit types, the length will be truncated to size_t. In non-release mode, you will get an exception if the length exceeds size_t.max in your call to iota.

std.algorithm.searching.minElement and std.algorithm.searching.maxElement are functions to search for the minimum and maximum element in a range. They support a custom map accessor.

import std.algorithm.searching;
import std.range;
import std.typecons;
assert([3, 1, 4].minElement == 1);
assert([4, 7, 5].enumerate.maxElement!`a.value` == tuple(1, 7));

std.math.quantize rounds to the nearest multiple of some number. Features:

• The rounding method can be specified using the rfunc parameter. By default, the current rounding mode will be used, which is typically "banker's rounding".
• Overloads are included for the common case of rounding to the Nth digit place in some base.
• If known at compile time, the base and exponent (digit place) can be supplied as template parameters for better performance.

import std.math;

assert(12345.6789L.quantize(20.0L) == 12340.0L);
assert(12345.6789L.quantize!(10, -2) == 12345.68L);
assert(12345.6789L.quantize!(10, floor)(-2) == 12345.67L);

std.traits.isType, std.traits.isFunction, and std.traits.isFinal were added to std.traits.

import std.traits;

static assert(isType!int);

struct S {}
class C {}
interface I {}

static assert(isType!S);
static assert(isType!C);
static assert(isType!I);

import std.traits;

void func(){}
struct S
{
    @property int prop(){ return 0; }
}

static assert(isFunction!func);
static assert(isFunction!(S.prop));

// is a delegate type, not function type
static assert(!isFunction!(typeof(&S.prop)));

import std.traits;

class C
{
    void nf() {}
    final void ff() {}
}
final class FC {}

static assert(!isFinal!(C));
static assert( isFinal!(FC));
static assert(!isFinal!(C.nf));
static assert( isFinal!(C.ff));

std.range.generate was set up to return a different value on each call to front. In addition, popFront did nothing. This means that manipulation functions like std.range.drop did nothing. The new version uses a one-element cache to meet the expectations of the range definition. It preserves the ref-ness of the generator as well.

std.experimental.typecons.Final can't be mutated directly. However references are typed with their original mutability. This is equivalent to final in Java or readonly in C#.

auto a = makeFinal([1, 2, 3]);
assert(a[0] == 1);

// a = [2, 3]; // Reassignment is illegal,
a[0] = 42; // Elements or fields are still mutable.

assert(a[0] == 42);

Classes, that are nested inside other classes (and not inside functions) and that don't define any outer symbol, have an outer field which allows to get and even set the instance of the outer class they are nested in. std.traits.isInnerClass allows to identify them. The types satisfying isInnerClass are a subset of the ones satisfying isNested, as the latter includes classes and structures nested inside functions or that redefine outer.

class Outer
{
    class Inner1 { }
    class Inner2
    {
        int outer; // redefines outer, so the Outer instance is not accessible
    }
    static class Inner3 {}  // static, thus not nested
}
static assert(isInnerClass!(Outer.Inner1));
static assert(!isInnerClass!(Outer.Inner2));
static assert(!isInnerClass!(Outer.Inner3));

If a class is nested within another class (there's a new trait std.traits.isInnerClass to check for this condition), emplace requires now the outer class instance as additional mandatory parameter. Before this change, emplacing did not require this parameter and access to variables of the outer class resulted in segmentation faults.

class Outer
{
    int x;
    class Inner
    {
        auto getX() { return x; }
    }
}
Outer outer = new Outer();

// auto inner = buf.emplace!(Outer.Inner)();   // this is no longer allowed
auto inner = buf.emplace!(Outer.Inner)(outer); // use this instead

auto x = inner.getX();  // this used to cause a segmentation fault;
                        // now it works as expected

This allows to select a GC at program startup.

./my_d_exe --DRT-gcopt=gc:conservative # use conservative GC (default)
./my_d_exe --DRT-gcopt=help # list available GC options

See gc_config for more information about gcopt.

In a future release it should be possible to extend the list of GCs by linking with an alternative one.

Use the --DRT-gc=gc:manual option to select the manual GC.

This GC is a thin wrapper around malloc and free and does not collect any garbage. It only releases memory explicity freed using GC.free. Builtin language constructs such as arrays or delegates that might allocate GC memory can leak. It supersedes the gcstub implementation.

The manual GC is useful for applications that deterministically control memory. Use dmd's -vgc switch to keep track of hidden allocations that might leak.

It can also be helpful to find memory corruptions with tools like valgrind.