Change Log: 2.074.0

TypeInfo.init has been @disabled. Use TypeInfo.initializer instead.

TypeInfo.init is a legacy alias of the method that is now called TypeInfo.initializer. The name change is necessary because the name "init" clashes with the type property of the same name (init).

The legacy alias has been deprecated since 2.072.0. It's going to be removed in 2.075.0.

std.range.bitwise creates a bit by bit adapter over an integral type range:

import std.range : bitwise;
ubyte[] arr = [3, 9];
auto r = arr.bitwise;

r[2] = 1;
assert(arr[0] == 7);

If a lambda with a single generic parameter is provided as a handler to std.variant.visit, it is invoked for any type contained in the Algebraic which does not have a handler for that type.

This allows something like:

// Assume Circle, Square, and Triangle all define center()
Algebraic!(Circle, Square, Triangle) someShape;
auto center = someShape.visit!(x => x.center);

This may be combined with explicitly typed handlers and a single fallback handler for an empty variant:

Algebraic!(int, float, string) something;
something.visit!((string s) => s.length, // called for string
                 x          => x,        // called for int/float
                 ()         => 0);       // called if empty

 import std.utf : decodeBack;

 string text = "サイト";

 assert(decodeBack(text) == 'ト');
 assert(decodeBack(text) == 'イ');
 assert(decodeBack(text) == 'サ');
 assert(text.empty);

std.algorithm.searching.minElement and std.algorithm.searching.maxElement are now considerably faster (almost 2x in microbenchmarks) as a special path for the identity case is provided. This allows the compiler to make use of SSE instructions.

The exact improvements are:

% dmd -release -O test.d && ./test
extremum.before = 54 secs, 12 ms, 347 μs, and 9 hnsecs
extremum.after  = 29 secs, 521 ms, 896 μs, and 5 hnsecs

% ldc -release -O3 test.d && ./test
extremum.before = 13 secs, 186 ms, 176 μs, and 4 hnsecs
extremum.after  = 2 secs, 241 ms, 454 μs, and 9 hnsecs

See the benchmark code.

std.format.formattedWrite and related functions now have overloads to take the format string as a compile-time argument. This allows the format specifiers to be matched against the argument types passed. Any mismatch or orphaned specifiers/arguments will cause a compile-time error:

import std.format, std.stdio;

auto s = format!"%s is %s"("Pi", 3.14);
assert(s == "Pi is 3.14");
writefln!"%c is %s"('e', 1.61);

static assert(!__traits(compiles, {s = format!"%l"();}));     // missing arg
static assert(!__traits(compiles, {s = format!""(404);}));    // surplus arg
static assert(!__traits(compiles, {s = format!"%d"(4.03);})); // incompatible arg

std.experimental.checkedint.Checked is a wrapper around any integral type that inserts checks against common sources of bugs: overflow in operators, mixed-sign comparisons, and casts that lose information.

The example below illustrates the basic use of the facility:

void main()
{
    import std.experimental.checkedint, std.stdio;
    writeln((checked(5) + 7).get); // 12
    writeln((checked(10) * 1000 * 1000 * 1000).get); // Overflow
}

By default, all checks are enabled and the program is aborted if any check fails. An implementation based on hooks discoverable by using Design by Introspection allows unbounded customizations of both the checks to do, and the enforcement policy.

import std.traits : hasStaticMember;

struct S
{
    static int staticVar;
    int nonstaticVar;
}

assert( hasStaticMember!(S, "staticVar"));
assert(!hasStaticMember!(S, "nonstaticVar"));

The synchronization between Phobos and Mir turned out to be a high amount of work with little gain. Users of std.experimental.ndslice are advised to switch to the upstream mir-algorithm package.

It comes with a lot of new features

• mir.ndslice.topology - Multidimensional std.range analog. Includes bitwise, bitpack, zip, unzip, map, indexed and many other features.
• mir.ndslice.concatenation - Concatenation and padding
• mir.ndslice.algorithm - Slim multidimensional std.algorithm analog
• mir.ndslice.sorting - Multidimensional sorting utilities

ndslice design was changed. New ndslices can be created on top of random access iterators including pointers. There are three kinds of ndslice:

• Contiguous - Contiguous in memory representation. It does not store strides and can be always flattened to 1 dimensional ndslice on top of the same iterator type.
• Canonical - BLAS like. Stride for row dimension assumed to be equal to 1.
• Universal - Numpy like. Each dimension has strides. All dimensions can be exchanged without reallocation. The old ndslice ABI corresponds to to the Universal ndslice.

When std.format.formattedRead is used with ref parameters it is @safe. For compatibility it's still possible to use std.format.formattedRead with pointers:

import std.format;
void main() {
    string text = "1 2 3";
    int a, b, c;
    formattedRead(text, "%d %d %d", a, b, c);
    // pointers can still be used
    formattedRead(text, "%d %d %d", &a, &b, &c);
    // and even combined:
    formattedRead(text, "%d %d %d", a, &b, c);
}

import std.stdio : readf;
void main() {
    // assume every line from stdin is similar to "1 2 3";
    int a, b, c;
    readf(" %d %d %d", a, b, c);
    // pointers can still be used
    readf(" %d %d %d, &a, &b, &c);
    // and even combined:
    readf(" %d %d %d, a, &b, c);
}

MersenneTwisterEngine has been updated so that its template signature matches the C++11 standard (adding two new template parameters, an extra tempering parameter d and the initialization multiplier f).

Handling of the word size w has been fixed so that the generator will now properly handle cases where it is less than the number of bits in the chosen UIntType. This has been validated against the behaviour of a widely-used implementation of the C++11 standard.

For anyone using the standard template instantiation Mt19937 this will have no noticeable effect. However, these will be breaking changes for anyone using the MersenneTwisterEngine template directly.

The internal implementation has been reworked to use Ilya Yaroshenko's highly optimized algorithm from mir-random. This should have a very noticeable positive effect for anyone who cares about generating a lot of random numbers quickly.

A new Mt19937_64 template instantiation has been added, corresponding to the standard 64-bit implementation of the algorithm (MT19937-64). This fixes https://issues.dlang.org/show_bug.cgi?id=10900.