Change Log: 2.077.0 (upcoming)

This allows the backend to emit AVX2 instructions. The compiler will add the predefined version D_AVX2. AVX2 support is automatically detected with -mcpu=native.

Many improvements were added to the dmd's -betterC implementation, most notably programs compiled with -betterC will no longer reference unused druntime symbols, asserts are implemented as C <assert.h> calls, and phobos is not linked by default.

See the Better C specs for more details.

URLs which appear in Ddoc text:

/****
 * http://www.fooa.com/test1
 */

will be treated as if they were written:

/****
 * $(LINK http://www.fooa.com/test1)
 */

and a clickable hyperlink will be emitted to the resulting .html file.

This detection does not happen if the URL is part of a macro argument:

/****
 * $(DOLLAR)$(LPAREN)ABC http://www.fooa.com/test1$(RPAREN)
 */

The behavior of that is unchanged. URLs can start with http:// or https://

http: and https: at the beginning of the line are no longer treated as section headings.

Support for static foreach has been added.

static foreach is a conditional compilation construct that is to foreach what static if is to if. It is a convenient way to generate declarations and statements by iteration.

import std.conv: to;

static foreach(i; 0 .. 10)
{

    // a `static foreach` body does not introduce a nested scope
    // (similar to `static if`).
    
    // The following mixin declaration is at module scope:
    mixin(`enum x` ~ to!string(i) ~ ` = i;`); // declares 10 variables x0, x1, ..., x9
}

import std.range: iota;
// all aggregate types that can be iterated with a standard `foreach`
// loop are also supported by static foreach:
static foreach(i; iota(10))
{
    // we access the declarations generated in the first `static foreach`
    pragma(msg, "x", i, ": ", mixin(`x` ~ to!string(i)));
    static assert(mixin(`x` ~ to!string(i)) == i);
}

void main()
{
    import std.conv: text;
    import std.typecons: tuple;
    import std.algorithm: map;
    import std.stdio: writeln;

    // `static foreach` has both declaration and statement forms
    // (similar to `static if`).
    
    static foreach(x; iota(3).map!(i => tuple(text("x", i), i)))
    {
        // generates three local variables x0, x1 and x2.
        mixin(text(`int `,x[0],` = x[1];`));

        scope(exit) // this is within the scope of `main`
        {
            writeln(mixin(x[0]));
        }
    }
    
    writeln(x0," ",x1," ",x2); // first runtime output
}

D exception handling was assuming the top level exception handler, so all exceptions would be handled somewhere. In case rt_trapExceptions is cleared, this handler would not be enabled, and this assertion would fail, aborting the program, but without any information about the exception. This is now changed, so the exception information will be printed to the stderr, followed by abort.

std.base64.Base64URLNoPadding allows encoding/decoding without padding:

import std.base64 : Base64URLNoPadding;

ubyte[] data = [0x83, 0xd7, 0x30, 0x7b, 0xef];
assert(Base64URLNoPadding.encode(data) == "g9cwe-8");
assert(Base64URLNoPadding.decode("g9cwe-8") == data);

Motivation:

The fully qualified name of the digest function template was std.digest.digest.digest. This is because std.digest is a package, with a module named digest in it, and the function digest inside that.

std.digest contains the former std.digest.digest package.

std.meta.Stride allows selecting a subset of template by a step size and offset:

alias attribs = AliasSeq!(short, int, long, ushort, uint, ulong);
static assert(is(Stride!(3, attribs) == AliasSeq!(short, ushort)));
static assert(is(Stride!(3, attribs[1 .. $]) == AliasSeq!(int, uint)));

Config.detached allows spawning processes which run independently from the current process. There is no need to wait on the processes created with this flag, and no zombie process will be left after they exit. Attempts to call std.process.wait or std.process.kill on detached processes will throw.

Now std.range.chunks can be used with input ranges that are not forward ranges, albeit with limited semantics as imposed by the underlying range.

import std.algorithm.comparison : equal;

int i;

// The generator doesn't save state, so it cannot be a forward range.
auto inputRange = generate!(() => ++i).take(10);

// We can still process it in chunks, but it will be single-pass only.
auto chunked = inputRange.chunks(2);

assert(chunked.front.equal([1, 2]));
assert(chunked.front.empty); // Iterating the chunk has consumed it
chunked.popFront;
assert(chunked.front.equal([3, 4]));

UNIX domain sockets are usually identified by pathnames. Linux offers a non-portable extension to this scheme, known as abstract socket addresses, which are independent of the filesystem. An abstract socket address starts with a null byte ('\0'), e.g.:

auto addr = new UnixAddress("\0/tmp/dbus-OtHLWmCLPR");

A second std.typecons.AutoImplement template has been added, which differs from the existing one in accepting an extra type parameter. The extra parameter specifies a class to derive from while auto-implementing an interface.

The base class used may contain non-default constructors. Matching constructors will be created in the auto-implemented class and be implemented as just a call to super with all arguments.

If you downloaded a zip/tar file with the compiler before and ran rdmd, it would invoke the D compiler from the system PATH rather than the compiler right next to it, failing if there wasn't one in the PATH. rdmd will now try to use the D compiler next to it first, and only fall back to the PATH if there isn't one adjacent. If you want rdmd to run a specific compiler, add the --compiler flag to force it, as always.

To restore the old behaviour of only using the compiler from your PATH, add --compiler=dmd (or ldmd2 or gdmd).