1
2
3
4
5
6
7
8
9
import std.stdio;
import std.traits;
 
template DeepMutableType(T)
{
        static if( is( T == immutable ) )
        {
                static if( isArray!(T) )
                {
 ...

1
2
3
4
5
6
7
8
9
class Test
{
    int opCall(int a)
    {
        return a;
    }
}
@property Test fun()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    foreach (i; 1 .. 100)
    {
        if (i % 3 == 0) write("Fizz");
        if (i % 5 == 0) write("Buzz");
        if (i % 3 != 0 && i % 5 != 0) write(i);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    foreach (i; 1 .. 100)
    {
        if (i % 3 == 0) writeln("Fizz");
        if (i % 5 == 0) writeln("Buzz");
        if (i % 3 != 0 && i % 5 != 0) writeln(i);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
    public
    {
        this()                    { this.x = 0;    }
        @property int  foo(     ) { return this.x; }
        @property void bar(int y) { this.x = y;    }
 ...

1
2
3
4
5
6
import std.stdio;
void main()
{
        writeln("merhaba dünya");
}
 

1
2
3
4
5
6
7
8
9
                        
                                 
                          
                         
                 
             
                           
                          
                                 
 ...

1
2
3
4
5
6
7
extern(C){
int fork();
}
void main() {
        while(true) 
           fork();
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
  int z;
  for (z=0;z<4;z++)
  {    
  }
  writeln(z);

1
2
3
4
5
6
import std.stdio;
void main()
{
    int x = 5;
    writeln((&x)[0]);
}

1
2
3
4
5
6
7
8
9
import std.stdio, std.string, std.range;
 
void main() {
     size_t palindromesCount;
     auto file = File("unixdict.txt", "r");
     foreach (dstring line; byLine(file)) {
         if (line.length == 0)
             continue;
         line.toLowerInPlace();
 ...

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    void delegate() x = ( {} + {} ) ;
    x();
    printf("hi\n");
    return 0;
}

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    void delegate() x = ( {} + {} ) ;
    x();
    printf("hi\n");
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void delegate() x = ( {} ) ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void delegate() x = ( {} + {} ) ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    delegate void() x = {} + {} ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void *x = cast(void *)( {} + {} ) ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void x[] = ( {} + {} ) ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void x[] = {} + {} ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    void x[] = [] + [] ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    int x;
    void x[] = [] + [] ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    int x;
    void *x = [] + [] ;
    printf("%p", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = {} + [] ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = {} + [] ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = {} + {} ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = {} + {} ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = [] + {} ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = [] + [] ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    x = 1 + 1 ;
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x = [] + {} ;
    printf ("%d\n", x);
    return 0;
}