1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    struct Foo
    {
        int a;
        float b;
        string c;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* TESTING FUNCTION */
 
int[] foo(T...)(T args)
{
    writeln("Called foo ...");
    foreach (i, arg; args)
        writefln("    args[%d] == %s", i, arg);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* TESTING FUNCTION */
 
int[] foo(T...)(T args)
{
    writeln("Called foo ...");
    foreach (i, arg; args)
        writefln("    args[%d] == %s", i, arg);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for 2.042 and older compilers (February 2010)
 * present on ideone
 */
struct My_Tuple(T...)
{
    Tuple!T base;
    alias base this;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for 2.042 and older compilers (February 2010)
 * present on ideone
 */
struct My_Tuple(T...)
{
    Tuple!T base;
    alias base this;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for 2.042 and older compilers (February 2010)
 * present on ideone
 */
struct My_Tuple(T...)
{
    Tuple!T base;
    alias base this;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
    struct My_Tuple(T...)
    {
        Tuple!T base;
        alias base this;
 
        this(T args) { this.base = Tuple!T(args); }
        U opIndex(U)(size_t idx) { return this.field[idx]; }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
    struct My_Tuple(T...)
    {
        Tuple!T base;
        alias base this;
 
        this(T args) { this.base(args); }
        U opIndex(U)(size_t idx) { return this.field[idx]; }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for old ass ideone compiler 
 * compilers prior to 2.042 (Feb 2010)
 */
static if (__VERSION__ <= 0)
{
    struct My_Tuple(T...)
    {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for old ass ideone compiler 
 * compilers prior to 2.042 (Feb 2010)
 */
static if (__VERSION__ <= 2041)
{
    struct My_Tuple(T...)
    {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for old ass ideone compiler 
 * compilers prior to 2.042 (Feb 2010)
 */
static if (__VERSION__ <= 2042)
{
    struct My_Tuple(T...)
    {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
/* hack for old ass ideone compiler 
 * compilers prior to 2.042 (Feb 2010)
 */
static if (__VERSION__ <= 2054)
{
    struct My_Tuple(T...)
    {
 ...

1
2
3
4
5
6
7
8
import std.stdio, std.typecons;
 
int[] foo(T...)(T args)
{
    writeln("Called foo ...");
    foreach (i, arg; args)
        writefln("    args[%d] == %s", i, arg);
    writeln("... foo end");
 ...

1
2
3
4
5
6
7
8
import std.stdio, std.typecons;
 
int[] foo(T...)(T args)
{
    writeln("Called foo ...");
    foreach (i, arg; args)
        writefln("    args[%d] == %s", i, arg);
    writeln("... foo end");
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.typecons;
 
void foo(T...)(T args)
{
    writeln("Called foo ...");
    foreach (i, arg; args)
        writefln("    args[%d] == %s", i, arg);
    writeln("... foo end");
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
ref   int foo(ref   int i) { return i; }
ref float foo(ref float f) { return f; }
 
auto transparent_forwarder(T)(T t) { return foo(t); }
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
ref   int foo(ref   int i) { return i; }
ref float foo(ref float f) { return f; }
 
auto transparent_forwarder(T)(T t) { return foo(t); }
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo()
{
    int i;
    void bar()
    {
        ++i;
    }
 ...

1
2
3
4
5
6
import std.stdio: writefln;
 
void main(string[] args) {
    foreach (i, arg; args)
        writefln("args[%d] = '%s'", i, arg);
}

1
2
3
4
5
6
7
8
import std.stdio;
 
int g;
 
void foo()
{
        g++;
}
 ...

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;
 
void forTest(T)(T[] array)
{
        writeln(array.length);
        foreach (int i; array)
        {
                write(i, ' ');
        }
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
 
void main(){
 
        writeln("Hello !");
 
}

1
2
3
4
5
6
7
8
9
import std.stdio, std.conv;
import core.stdc.stdlib;
 
/* ALLOCATION AND DEALLOCATION MECHANISMS */
 
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];
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import core.stdc.stdlib;
 
/* ALLOCATION AND DEALLOCATION MECHANISMS */
 
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];
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import core.stdc.stdlib;
 
class Foo
{
    this() { writeln("ctor"); }
 
    new(size_t size) {
        void* mem = malloc(size);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
    this() { writeln("ctor"); }
 
    new(size_t size) {
        void* mem = malloc(size);
        if  (!mem) throw new Exception("Failed alloc");
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo()
{
    this() { writeln("ctor"); }
 
    new(size_t size) {
        void* mem = malloc(size);
        if  (!mem) throw new Exception("Failed alloc");
 ...

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;
 ...