Change Log: 2.112.0

Similar to auto ref parameters in 2.111, it's now deprecated to declare an auto ref return type without putting those two keywords next to each other as well.

ref auto int f() => 3;
auto { ref int g() => 3; }

// Correction:
auto ref f() => 3;
auto ref g() => 3;

The compiler now accepts c++23 as a supported standard for -extern-std=. Currently this only changes the value of __traits(getTargetInfo, "cppStd").

These map to a single x86_64 instruction and have accordingly been optimized via inline assembly.

import core.int128;

ulong a, b;
Cent product128 = mul(a, b);

ulong divisor64 = …;
ulong modulus64;
ulong quotient64 = udivmod(product128, divisor64, modulus64);

macOS 15.4 has introduced an undocumented ABI change to the format of thread local variable section, which causes almost all executable built with previous D compiler versions to crash during initialization, if they use DRuntime. This release introduces a mitigation for this issue that is backwards compatible with previous versions of macOS.

This prevents linking errors when using -betterC. For example:

import core.sys.posix.stdlib;
import core.sys.posix.unistd;

extern(C) int main()
{
    int status, pid = vfork();
    if (pid == 0)
    {
        // ...
        return 0;
    }

    waitpid(pid, &status, 0);
    if (WIFEXITED(status))
    {
        // ...
    }
    return 0;
}

This would fail to compile with the -betterC flag:

Error: undefined reference to `core.sys.posix.sys.wait.WIFEXITED(int)`
       referenced from `main`

The reason is that WIFEXITED is a C macro that was translated to a D function in druntime, which requires linking with druntime to use. Now that it's a template, it will be lazily instantiated and the program compiles.

The new lazyCache function provides a lazily evaluated range caching mechanism. Unlike cache, which eagerly evaluates range elements during construction, lazyCache defers evaluation until elements are explicitly requested.

auto result = iota(-4, 5).map!(a => tuple(a, expensiveComputation(a)))().lazyCache();
// No computations performed at this point

auto firstElement = result.front;
// First element is now evaluated

See the std.algorithm.iteration.lazyCache documentation for more details.

To restore compatibility with older Linux platforms where getrandom() is unavailable either due to an outdated kernel or a legacy C library, Phobos now ships with a shim that emulates a limited subset of getrandom()’s behavior by reading random bytes from /dev/urandom.

To enable the shim, build DMD and Phobos with the environment variable LINUX_LEGACY_EMULATE_GETRANDOM set to 1.

cd phobos
LINUX_LEGACY_EMULATE_GETRANDOM=1 make

This functionality is a temporary fix and expected to be removed again soon by an upcoming release (approx. v2.112.0 or v2.113.0). The expected change is to replace the current “binding or shim” solution with a syscall wrapper and automatic /dev/urandom fallback.

This Phobos release introduces an internal multi-backend system for the retrieval of entropy (as in cryptographically-secure random numbers obtained from a suitable random number generator provided by the operating system).

The current implementation supports the getrandom syscall on Linux.

On BSD systems arc4random_buf or getentropy are used — depending on which is implemented by the OS and powered by a secure (non-RC4) algorithm.

Additionally, reading entropy from the character devices /dev/urandom and /dev/random is available on all POSIX targets.

On Windows BCryptGenRandom (from the Cryptography API: Next Generation (“BCrypt”)) is provided as a backend. CryptGenRandom from the legacy CryptoAPI is not supported for the time being.

Furthermore, this replaces the getrandom backwards compatibility shim that had been added by v2.111.1 for Linux targets. Instead backwards compatibility is now provided by a hunt strategy algorithm that tries potentially available entropy sources one by one to find one that is available on the running system. Given that the character devices serve as a fallback option here, urandom is favored over random. That is because modern kernel versions — where random would exhibit the usually more preferable behavior of blocking only until the entropy pool has been initialized — will also provide the getrandom syscall in the first place. Performing the syscall, in turn, is even better as it does not depend on the runtime environment exposing the special devices in predefined locations, thus working also within chroot environments.

These functions are variants of the existing text, wtext, and dtext functions. Instead of returning a string, they write their output to an output range.

Like text, writeText can accept an interpolated expression sequence as an argument.

Example:

import std.conv : writeText;
import std.array : appender;

auto output = appender!string();
output.writeText(i"2 + 2 == $(2 + 2)");
assert(output.data == "2 + 2 == 4");