run-dlang

import std.stdio;
void main()
{
    writeln("Hello D2222");
}

run-dlang

import std.stdio;
void main()
{
    writeln("Hello D2222");
}

run-dlang

import std.stdio;
void main()
{
    writeln("Hello D2222");
}

run-dlang

struct Test(T...)
{
    T field;
    
    this (T t) { field = t; }
    
    bool opEquals(R...)(const auto ref R rhs) inout
    {
        static foreach (i, _; T)
            if (field[i] != rhs[i])

run-dlang

void main()
{
    import std.experimental.allocator;
    import std.experimental.allocator.mallocator: Mallocator;
    import std.experimental.allocator.gc_allocator : GCAllocator;
    auto newAlloc = sharedAllocatorObject(Mallocator.instance);
    processAllocator() = newAlloc;
    assert(processAllocator is newAlloc);
    processAllocator = sharedAllocatorObject(GCAllocator.instance);
}

run-dlang

void main()
{
    import std.stdio: write, writeln, writef, writefln;
    int i;
    
    enum Foo { E }
    Foo f;
    i = f;           // OK
    f = i;           // error
    f = cast(Foo)i;  // OK

run-dlang

import std.stdio;

mixin template Enforcement(T) {
    private bool _ensured;
    private Throwable _throwable;
    
    ~this() {
        if (this.hasThrowable) {
            throw _throwable;
        }

run-dlang

import std.concurrency : receiveOnly, send,
    spawn, Tid, thisTid;
import core.atomic : atomicOp, atomicLoad;

import core.sync.mutex;

shared Mutex mtx;

/*
Queue that can be used safely among

run-dlang

import std.concurrency : receiveOnly, send,
    spawn, Tid, thisTid;
import core.atomic : atomicOp, atomicLoad;

import core.sync.mutex;

shared Mutex mtx;

/*
Queue that can be used safely among

run-dlang

import std.concurrency : receiveOnly, send,
    spawn, Tid, thisTid;
import core.atomic : atomicOp, atomicLoad;

import core.sync.mutex;

shared Mutex mtx;

/*
Queue that can be used safely among