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

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
        writeln( SIZE!int );
}
 
size_t SIZE(T)()
{
 ...

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    while (scanf("%d", &x) && x!=42) printf ("%d\n", x);
    return 0;
}

1
2
3
4
5
6
7
8
9
/+
コンパイル時に素数ならコンソール画面にtrueと出る。
しかもmain関数やその他関数ナシ。
このコードをコンパイルすると、コンパイル時に
test.d(9): Error: static assert  true
と出る。
+/
 
static assert(0,isPrime!(127)?"127 is a prime number":"127 is not a prime number");
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
version = 5;
 
void main()
{
    writeln("test");
    
    version()
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
version = 5;
 
void main()
{
    writeln("test");
    
    version(7)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
version = 5;
 
void main()
{
    writeln("test");
    
    version(4)
 ...

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
template A(string P1){
        template B(string P2) {
                string func() { return P1 ~ P2; }
        }
}
 
mixin A!("hoge").B!("piyo");

1
2
3
4
5
6
7
8
9
package weihnachtsbaum;
 
class App {
        public static void main(String[] args) {
                int h=10;
                int l=2*h+1;
                
                private boolean{
                boolean dreieck [][] = new boolean [l] [h]; { 
 ...

1
2
3
4
5
6
7
8
9
bool isSuccess(){
    import std.random;
    Mt19937 gen;
    string str = __DATE__ ~ __TIME__;
    uint hash;
    foreach (c; str){
        hash = (hash * 9) + c;
    }
    gen.seed(hash);
 ...

1
2
3
4
5
void main() {
  struct Opaque;
  void* vp;
  Opaque* op = cast(Opaque*)vp;
}

1
2
3
4
5
6
7
struct Foo;
struct Bar;
 
void main() {
    Foo* foo;
    Bar* bar = cast(Bar*)foo;
}

1
2
3
4
5
6
7
8
9
import std.stdio, std.conv, std.traits;
import std.c.stdlib;
 
T o_new(T, U...)(U args) if (is(T == class))
{
    size_t sz = __traits(classInstanceSize, T);
    void *tmp = malloc(sz);
 
    return emplace!T(tmp[0..sz], args);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.conv, std.traits;
import std.c.stdlib;
 
T o_new(T, U...)(U args) if (is(T == class))
{
    size_t sz = __traits(classInstanceSize, T);
    void *tmp = malloc(sz);
 
    return emplace!T(tmp[0..sz], args);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.conv, std.traits;
import std.c.stdlib;
 
T o_new(T, U...)(U args) if (is(T == class))
{
    size_t sz = __traits(classInstanceSize, T);
    void *tmp = malloc(sz);
 
    return std.conv.emplace!T(tmp[0..sz], args);
 ...

1
2
3
4
5
6
7
8
9
/*!
 * jQuery JavaScript Library v1.4.2
 * http://jquery.com/
 *
 * Copyright 2010, John Resig
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * Includes Sizzle.js
 ...

1
2
3
4
5
6
7
8
9
class Module
{
    
    static void compileObjs()
    {
        
        import std.parallelism;
    }
}

1
2
3
4
5
6
7
8
9
import std.stdio;
class C
{
 
        final method(){writeln("HW");}
}
 
 
void main()
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
class C
{
 
        final method(){writeln("HW")}
}
 
 
void main()
 ...

1
2
3
4
5
6
7
8
9
std.stdio;
class C
{
 
        final method(){writeln("HW")}
}
 
 
void main()
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class C
{
        final void f() { writeln("Hello"); }
}
 
void main()
{
 ...

1
2
3
4
5
6
7
import std.stdio;
 
void main(){
        foreach(i; 0..20){
                writeln(i);
        }
}

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

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

1
2
3
4
5
6
7
8
9
struct Test {
        double a = 0.4;
        double b;
        this(double b) {
                this.b = b;
        }
}
 
Test t2 = { 0.0, 1.0 };

1
2
3
4
5
6
7
8
9
import std.string;
import std.stdio;
struct Test{
    int a;
    uint b;
    this( int a, uint b ){
        this.a = a;
        this.b = b;
    }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void die(T...)(T t)
{
        foreach(v; t)
        {
                *v = 0;
        }
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void die(T...)(T t)
{
        foreach(v; t)
        {
                v = 0;
        }
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void die( ... )
{
        real* foo = *cast( real** )_argptr;//これは、real*型へのvoid*型ポインタ。
        *foo = 0.0;
}
 
void main()
 ...