Change Log: 2.100.0

Formerly, the return sometimes applied to the ref instead, which can be confusing. If return scope does not appear adjacent and in that order, the return will apply to the ref.

If used inside a function, this trait yields a tuple of the parameters to that function for example:

int echoPlusOne(int x)
{
    __traits(parameters)[0] += 1;
    return x;
}

This can be used to simply forward a functions parameters (becoming arguments of another), in effect unifying functions with variadic parameters and normal functions i.e. the following pattern is now possible without use of variadics:

int add(int x, int y)
{
    return x + y;
}

auto forwardToAdd(Pack...)(Pack xy)
{
    return add(xy);
}

would become

int add(int x, int y)
{
    return x + y;
}

auto forwardToAdd(int x, int y)
{
    return add(__traits(parameters));
}

When used inside a nested function or lambda, the trait gets the arguments of that and only that nested function or lambda, not what they are contained in.

For example, these assertions hold:

int testNested(int x)
{
    static assert(typeof(__traits(parameters)).length == 1);
    int add(int x, int y)
    {
        static assert(typeof(__traits(parameters)).length == 2);
        return x + y;
    }
    return add(x + 2, x + 3);
}

When used inside a foreach using an overloaded opApply, the trait yields the parameters to the delegate and not the function the foreach appears within.

class Tree {
    int opApply(int delegate(size_t, Tree) dg) {
        if (dg(0, this)) return 1;
        return 0;
    }
}
void useOpApply(Tree top, int x)
{
    foreach(idx; 0..5)
    {
        static assert(is(typeof(__traits(parameters)) == AliasSeq!(Tree, int)));
    }
    foreach(idx, elem; top)
    {
        static assert(is(typeof(__traits(parameters)) == AliasSeq!(size_t, Tree)));
    }
}

ImportC can now import modules with the __import keyword, with the C code:

__import core.stdc.stdarg; // import a D source file
__import test2;            // import an ImportC file

int foo() { va_list x; return 1 + A; }

test2.c is:

enum E { A = 3 };

The syntax for __import after the keyword is the same as for D's import declaration.

Prior to this release, casting between built-in sequences of the same type was not allowed.

Starting with this release, casting between sequences of the same length is accepted provided that the underlying types of the casted sequence are implicitly convertible to the target sequence types.

alias Seq(T...) = T;

void foo()
{
    Seq!(int, int) seq;

    auto foo = cast(long) seq;
    pragma(msg, typeof(foo)); // (int, int)

    auto bar = cast(Seq!(long, int)) seq; // allowed
    pragma(msg, typeof(bar)); // (long, int)
}

The new -vasm compiler switch will print to the console the generated assembler code for each function. As opossed to a typical dissasembler, it will omit all the boilerplate and output just the assembly code for each function. For example, compiling the following code:

// test.d
int demo(int x)
{
    return x * x;
}

by using the command dmd test.d -c -vasm will yield:

_D4test4demoFiZi:
0000:   89 F8                   mov     EAX,EDI
0002:   0F AF C0                imul    EAX,EAX
0005:   C3                      ret

Integer promotions now follow C integral promotions rules consistently It affects the unary - and ~ operators with operands of type byte, ubyte, short, ushort, char, or wchar. The operands are promoted to int before the operator is applied, and the resulting type will now be int.

To revert to the old behavor, either use the '-revert=intpromote' switch, or explicitly cast the result of the unary operator back to the smaller integral type:

void main()
{
    // Note: byte.max = 127, byte.min = -128
    byte b = -128;
    int x = -b; // new behavior: x = 128
    int y = cast(byte)(-b); // old behavior: y = -128
    byte b2 = cast(byte) -b; // cast now required
}

The -m32mscoff switch is deprecated and -m32 should be used in its place. A new switch -m32omf has been added to produce code for OMF. Use of this switch is discouraged because OMF will soon be unsupported.

This mainly means that unittests inside templates are now only instantiated if the module lexically declaring the template is one of the root modules.

E.g., compiling some project with -unittest does NOT compile and later run any unittests in instantiations of templates declared in other libraries anymore.

Declaring unittests inside templates is considered an anti-pattern. In almost all cases, the unittests don't depend on the template parameters, but instantiate the template with fixed arguments (e.g., Nullable!T unittests instantiating Nullable!int), so compiling and running identical tests for each template instantiation is hardly desirable. But adding a unittest right below some function being tested is arguably good for locality, so unittests end up inside templates.

To make sure a template's unittests are run, it should be instantiated in the same module, e.g., some module-level unittest.

This change paved the way for a more straight-forward template emission algorithm without -unittest special cases, showing significant compile-time improvements for some projects. -allinst now emits all templates instantiated in root modules.

If main never returns (due to an infinite loop or always throwing an exception), it can now be declared as returning noreturn. See https://dlang.org/spec/type.html#noreturn.

If main is declared with auto, the inferred return type must be one of void, int and noreturn.

This was deprectated in 2.072.2 because it is a common mistake to forget a break statement at the end of a switch case. The deprecation warning has now been turned into an error.

If you intend to let control flow continue from one case to the next, use the goto case; statement.

void parseNumFmt(char c, out int base, out bool uppercase)
{
    switch (c)
    {
        case 'B': // fallthrough allowed, case has no code
        case 'b':
            base = 2;
            // error, accidental fallthrough to case 'X'
        case 'X':
            uppercase = true;
            goto case; // allowed, explicit fallthrough
        case 'x':
            base = 16;
            break;
        default:
            break;
    }
}

Prior to this release, throw was considered as a statement and hence was not allowed to appear inside of other expressions. This was cumbersome e.g. when wanting to throw an expression from a lambda:

SumType!(int, string) result;

result.match!(
    (int num)       => writeln("Found ", num),
    // (string err) => throw new Exception(err)    // expression expected
    (string err)     { throw new Exception(err); } // ok, introduces an explicit body

);

throw is now treated as an expression as specified by DIP 1034 [1], causing it to become more flexible and easier to use.

SumType!(int, string) result;

result.match!(
    (int num)    => writeln("Found ", num),
    (string err) => throw new Exception(err)   // works

);

[1] https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1034.md

Using __traits(initSymbol, A) where A is either a class or a struct will yield a const(void)[] that holds the initial state of an instance of A. The slice either points to the initializer symbol of A or null if A is zero-initialised - matching the behaviour of TypeInfo.initializer().

This traits can e.g. be used to initialize malloc'ed class instances without relying on TypeInfo:

class C
{
    int i = 4;
}

void main()
{
    const void[] initSym = __traits(initSymbol, C);

    void* ptr = malloc(initSym.length);
    scope (exit) free(ptr);

    ptr[0..initSym.length] = initSym[];

    C c = cast(C) ptr;
    assert(c.i == 4);
}

Support OpenBSD ioctls as found in OpenBSD's /usr/include/sys/filio.h, /usr/include/sys/ioccom.h, /usr/include/sys/ioctl.h, and /usr/include/sys/ttycom.h.

object.opEquals is now @safe if the static types being compared provide an opEquals method that is also @safe.

std.experimental.checkedint is now std.checkedint. The old name is still available and publicly imports the new one, and is also deprecated.

std.algorithm.iteration.splitWhen now infers safety from the underlying range, as most Phobos ranges do. std.algorithm.iteration.chunkBy also does that when instantiated with a forward range. Inference for chunkBy with a non-forward input range is not yet implemented, though.

@safe void fun()
{
    import std.algorithm;

    // Grouping by particular attribute of each element:
    auto data = [
        [1, 1],
        [1, 2],
        [2, 2],
        [2, 3]
    ];

    auto r1 = data.chunkBy!((a,b) => a[0] == b[0]);
    assert(r1.equal!equal([
        [[1, 1], [1, 2]],
        [[2, 2], [2, 3]]
    ]));

    auto r2 = [1, 2, 3, 4, 5, 6, 7, 8, 9].splitWhen!((x, y) => ((x*y) % 3) > 0);
    assert(r2.equal!equal([
        [1],
        [2, 3, 4],
        [5, 6, 7],
        [8, 9]
    ]));
}

By default std.csv will throw if the number of columns on a line is not equal to the number of columns of the first line. To allow, or disallow, a variable amount of columns a bool can be passed to all overloads of the csvReader function as shown below.

string text = "76,26,22\n1,2\n3,4,5,6";
auto records = text.csvReader!int(',', '"', true);

assert(records.equal!equal([
    [76, 26, 22],
    [1, 2],
    [3, 4, 5, 6]
]));

std.experimental.logger.core.sharedLog now returns by default a logger with its log level set to LogLevel.warning.

The previous version of to did not support conversions to std.typecons tuples. Starting with this release, tuples are now supported as highlighted in the following example:

void main()
{
    import std.conv : to;
    import std.typecons : Tuple;
    auto data = ["10", "20", "30"];
    auto a3 = data.to!(int[3]);                // accepted in previous and current versions
    auto t3 = data.to!(Tuple!(int, int, int)); // rejected in past versions, accepted now
}