Change Log: 2.065.0

On Posix systems it is frequently useful to have a shebang line at the start of an extensionless file, which marks the tool used to compile the script. It's now possible to use this technique with D, e.g. the following is a D source file with the file name "my-script":

#!rdmd

void main()
{
}

Note: This does not allow an arbitrary extension, as D source files need to be proper D identifiers.

Note: This feature is not available on Windows, as Windows does not have extensionless executable files.

Note: When compiling, and in order to avoid the default behavior of generating an extensionless executable which would overwrite the source file, the compiler will generate "a.out" instead.

For a very long period, the following code had been allowed by mistake, but it is prohibited now:

import std.stdio;

void main()
{
    goto Label; // Error: goto skips declaration of variable v

    int v = 42;

Label:
    writeln(v);
}

Regardless of how directly or indirectly a function is instantiated, its attributes will still be inferred:

struct S(T)
{
    T square(T x)
    {
        T calc()
        {
            return x * x;
        }
        return calc();
    }

    static double pi() { return 3.141592; }
}

void main() pure @safe nothrow
{
    S!int s;

    // S!int.square and its nested function calc are instantiated functions, so
    // their attributes are inferred as pure and callable from main()
    assert(s.square(2) == 4);  // ok

    // static member function attributes are also inferred now
    auto pi = typeof(s).pi();
}

Until now, the common type of immutable(T) and inout(T) had been const(T). But that loses the inout information, which might then refuse some valid code. Now the type becomes inout(const(T)), which meaningfully propagates the appropriate type qualifier.

inout(const(int))[] foo(bool condition, inout(int)[] x, immutable(int)[] y)
{
    static assert(is(typeof(condition ? x : y) == inout(const(int))[]));
    return condition ? x : y;
}

void main()
{
    int[] marr = [1,2,3];
    const(int)[] carr = [4,5,6];
    immutable(int)[] iarr = [7,8,9];

    // inout(const(int))[] can go back to const(int)[] or immutable(int)[].
    static assert(is(typeof(foo(true, marr, iarr)) == const(int)[]));
    static assert(is(typeof(foo(true, carr, iarr)) == const(int)[]));
    static assert(is(typeof(foo(true, iarr, iarr)) == immutable(int)[]));
}

Bugzilla 8244: cannot slice a type tuple with '[]' in locations where a type is valid:

import std.typetuple;
alias Types = TypeTuple!(int, double, string);

// Was error in 2.064, but allowed from 2.065.
alias Types2 = Types[];
static assert(is(Types == Types2));

Bugzilla 9081: Modules shouldn't have a type

import std.stdio;

// Both had printed 'void' in 2.064.
// From 2.065, both will cause "has no type" error.
pragma(msg, typeof(std));
pragma(msg, typeof(std.stdio));

By the change, an idiom that used to work is(typeof(package_or_module_name)) is changed to not work. Instead use: __traits(compiles, package_or_module_name).

Eventually, they will be changed to occupy space in the object. Such fields should now be changed to enum or static. See also the release note in 2.063.

Related to that, void-initialized const or immutable fields will now occupy space in the object instance ahead of schedule:

struct S
{
    const int[1000] x = void;

    this(int n)
    {
        // Was disallowed in 2.064.
        // From 2.065 x is a field of runtime object.
        x[] = n;
    }
}

// S.sizeof had been 1 in 2.064.
// From 2.065, field s.x occupies space in the object.
static assert(S.sizeof == int.sizeof * 1000);

void main()
{
    S s = S(3);

    foreach (e; s.x)
    {
        assert(e == 3); // OK
    }
}

Bugzilla 10369: Deprecate unordered floating point comparisons

Bugzilla 10439: Deprecate float.min, double.min, real.min

Example code:

union U
{
    size_t x;
    int* y;
}

bool test()
{
    U u;
    assert(u.x == 0);
    // In here, reading u.y will cause CTFE error.

    u.y = [1,2,3].ptr;
    // Writing value to overlapped field u.y will make corresponding field u.x invalid.

    assert(u.y[0..3] == [1,2,3]);
    // u.y holds valid field and reading it is allowed
    // In here, reading u.x will cause CTFE error.

    u.x = 10;
    // Set value to u.x again.
    assert(u.x == 10);  // OK
    // In here, reading u.y will cause CTFE error.

    return true;
}
static assert(test());  // run CTFE

Bit image reinterpretation by using two overlapped union fields is not allowed during CTFE.

The new getAliasThis trait will return a tuple of field names which are marked as the subtypes of an aggregate type. For example:

struct S
{
    string var;
    alias var this;
}

static assert(__traits(getAliasThis, S)[0] == "var");

Note: Multiple subtyping is not yet implemented in D, therefore this trait will always return a tuple of length 1.

This was not implemented correctly and caused ambiguities.

Example:

struct S
{
    this(int i) {}

    static S opCall()   // disallowed due to constructor
    {
        return S.init;
    }
}

Note: static opCall can be used to simulate struct constructors with no arguments, but this is not recommended practice. Instead, the preferred solution is to use a factory function to create struct instances.

Functions such as any, all, canFind and equal are now templates, which allows them to be used as predicates to other templates, as well as allowing the user to alias an instantiation of any such templates. For an example of how this allows terser syntax in user-code, in the following example the programmer wants to check whether all the strings in a string array have at least one ASCII digit:

import std.algorithm : all;
import std.ascii : isDigit;

void main()
{
    string[] inputs = ["foo1", "bar2"];

    bool allContainDigit;
    foreach (input; inputs)
    {
        if (!any!isDigit(input))  // none of the characters are ASCII digits
        {
            allContainDigit = false;
            break;
        }
    }
}

But it is now simpler to use the any template itself as a predicate. We can make it a predicate to another useful template, the all template:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    string[] inputs = ["foo1", "bar2"];
    bool allContainDigit = all!(any!isDigit)(inputs);
}

In addition to allowing these functions to become predicates they can now also be aliased, which allow you to make your functions simpler to understand:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias isAnyDigit = any!isDigit;  // less visual noise and a self-describing function

    string[] inputs = ["foo1", "bar2"];
    bool allContainDigit = all!isAnyDigit(inputs);  // easier to understand

    alias doAllContainDigits = all!isAnyDigit;  // or wrap the entire algorithm into one symbol!

    assert( doAllContainDigits(["1", "a 1", "b 2"]));  // self-describing code
    assert(!doAllContainDigits(["c", "a 1", "b 2"]));
}

You can of course combine all and any in a number of combinations. For example, if you want to reverse the test and instead check whether any of the strings in the string array contain all digits, the code might look like the following:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias areAllDigits = all!isDigit;

    alias areAnyIntegrals = any!areAllDigits;

    assert( areAnyIntegrals(["123", "456"]));
    assert( areAnyIntegrals(["abc", "123"]));  // "123" is a number
    assert(!areAnyIntegrals(["abc", "def123"])); // "def123" is not really a number
}

If on the other hand you want to ensure that all strings in the string array contain all digits, the could might look like the following:

import std.algorithm : any, all;
import std.ascii : isDigit;

void main()
{
    alias areAllDigits = all!isDigit;

    alias allStringsDigits = all!areAllDigits;

    assert( allStringsDigits(["123", "456"]));
    assert(!allStringsDigits(["abc", "123"]));  // "123" is a number, but "abc" is not
}

You no longer need to pass a predicate if you want to match all items in a range which implicitly convert to true:

import std.algorithm;

void main()
{
    auto arr1 = [true, true, true];
    assert( all(arr1));  // all values are true

    auto arr2 = [false, true, true];
    assert(!all(arr2));  // all values are not true

    auto arr3 = [1, 2, 3];
    assert( all(arr3));  // all values convert to true

    auto arr4 = [0, 2, 3];
    assert(!all(arr4));  // all values do not convert to true
}

Complementary higher-order ranges which enable range operations on graphemes:

import std.array : array;
import std.range : retro;
import std.string : text;
import std.uni : byCodePoint, byGrapheme;

void main()
{
    string s = "noe\u0308l"; // noël
    // reverse it and convert the result back to UTF-8
    string reverse = s.byGrapheme()
        .array() // Note: byGrapheme will support bidirectionality in the future
        .retro()
        .byCodePoint()
        .text();

    assert(reverse == "le\u0308on"); // lëon
}

only can now be used with more than one argument:

import std.algorithm : joiner;
import std.range : equal, only;

void main()
{
    assert(only("one", "two", "three").joiner(" ").equal("one two three"));
}

Additionally, only() is now a way to get an empty range.

When using the default Optlink linker on win32 (for linking 32-bit object files and executables), the /LARGEADDRESSAWARE option tells the linker that the application can handle addresses larger than 2 gigabytes. This is equivalent to Visual C's linker option of the same name since this is an operating-system feature that is enabled by setting a specific flag in the executable.