1
2
3
4
5
6
7
 
struct S {}
 
void main()
{
        int[] x = cast(S[])[];
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
    int opApply(int delegate(int a, int b, int c) dg)
    {
        int ret = 0;
 
        if ((ret = dg(5, 10, 15)) != 0) return ret;
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
void main()
{
    int i = 5;
 
    T foo(T)(T a, T b)
    { i += 150; return a + b; }
 ...

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{
    int x = (a,b) { return a+b; };
}
 

1
2
3
4
5
6
import std.stdio;
 
void main()
{
    int x = ((a,b) { return a+b; })(4,5)
}

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{
    auto x = (a,b) { return a+b; };
    writeln(x(3,5));
}

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{
    auto x = 3;
    writeln(x);
}

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{
    auto x = ((a,b) => a+b);
    writeln(x(3,5));
}

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{
    auto x = (a,b) => a+b;
    writeln(x(3,5));
}

1
2
3
4
5
6
7
8
import std.stdio;
 
class X
{
    int i;
    private void foo() {}
    this() {}
}
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
class X
{
    int i;
    private void foo() {}
    this() {}
}
 ...

1
2
3
4
5
6
7
8
template ReturnType(func...)
    if (func.length == 1 && isCallable!(func))
{
    static if (is(FunctionTypeOf!(func) R == return))
        alias R ReturnType;
    else
        static assert(0, "argument has no return type");
}

1
2
3
4
5
6
7
8
9
template FunctionTypeOf(func...)
    if (func.length == 1 && isCallable!(func))
{
    static if (is(typeof(& func[0]) Fsym : Fsym*) && is(Fsym == function) || is(typeof(& func[0]) Fsym == delegate))
    {
        alias Fsym FunctionTypeOf; // HIT: (nested) function symbol
    }
    else static if (is(typeof(& func[0].opCall) Fobj == delegate))
    {
 ...

1
2
3
4
5
6
7
8
template ReturnType(func...)
    if (func.length == 1 && isCallable!(func))
{
    static if (is(FunctionTypeOf!(func) R == return))
        alias R ReturnType;
    else
        static assert(0, "argument has no return type");
}

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(void delegate(int, int) x) { x(5, 10); }
 
void main()
{
    foo((int a, int b) { writeln(a+b); });
}

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(void delegate(int, int) x) { x(5, 10); }
 
void main()
{
    foo((a, b) { writeln(a+b); });
}

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(T)(T x) { x(5, 10); }
 
void main()
{
    foo((a, b) { writeln(a+b); });
}

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(string x) { foreach (i, ch; x) writefln("x[%d] == '%c'", i, ch); }
 
void main()
{
    foo("hello world");
}

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(string x) { foreach (i, ch) writefln("x[%d] == '%c'", i, ch); }
 
void main()
{
    foo("hello world");
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(ref int[42] x) { writeln(x); }
 
void main()
{
    int[42] bah;
    foo(bah);
}

1
2
3
4
5
6
7
8
import std.stdio;
 
auto x(T)(T a, T b) { return a + b; }
 
void main()
{
    writeln(x(5, 10));
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(T...)(T args)
{
    foreach(arg; args[2..$]) writeln(arg);
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(T...)(T args)
{
    foreach(arg; args) writeln(arg);
}
 
void main()
{
 ...

1
2
3
4
5
6
7
 
import std.stdio;
 
void main()
{
        writeln(__VERSION__);
}

1
2
3
4
5
6
7
8
9
 
import std.stdio;
 
void main()
{
        uint src = 0xffffffff;
        uint r = (src & 0x00ff0000) >> 16;
        uint g = (src & 0x0000ff00) >> 8;
        uint b = src & 0x000000ff;
 ...

1
2
3
4
5
6
7
8
9
f=@(x)exp(-x)-x;
df=@(x)-exp(-x)-1;
root=fzero(f,0.6);
% N-R method
x(1)=1;
x(2)=x(1)-f(x(1))/df(x(1));
err_app(1)=1;
err_app(2)=abs((x(2)-x(1))/x(2));
i=2;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import std.c.stdlib;
 
T o_new(T, U...)(U args) if (is(T == class))
{
    size_t sz  = __traits(classInstanceSize, T);
    void[] mem = calloc(sz, byte.sizeof)[0 .. sz];
 
    if (mem.length < sz) return null;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
struct Foo
{
    public void opAssign(int x) { this.y = x; }
    public int y;
}
 
void main()
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
struct Foo
{
    public void opCall(int x) { this.y = x; }
    public int y;
}
 
void main()
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
    public void opCall(int x) { this.y = x; }
    public int y;
}
 
void main()
 ...