1
2
3
4
5
6
7
8
9
import std.stdio;
void foo(T...)(T args)
{
    writeln("runtime");
    static assert(args.length == 6);
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(T...)(T args)
in
{
    /* if it won't be 6, it won't even compile */
    static assert(args.length == 6);
}
body
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(T...)(T args)
in
{
    /* if it won't be 6, it won't even compile */
    static assert(args.length == 6);
}
body
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: E*, E)(T t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T* t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T* t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T* t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T* t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T t)
{
  writeln("T");
}
 
void f(T: T*)(T t)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T)
{
  writeln("T");
}
 
void f(T: U*, U)(T)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f(T)(T)
{
  writeln("T");
}
 
void f(T: T*)(T)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void f!(T)(T)
{
  writeln("T");
}
 
void f!(T: T*)(T)
{
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
int main()
{
        std.stdio.writefln("Hello World!");
        std.stdio.readln;
        return 0;
}

1
2
3
4
5
6
7
8
9
f~^kn~+c+ia~^+~cf+?/                        
                   [f!c-ki~:~b/au>++*+k~~r~bn!*+i                   
                <kk]k/>rkbrn~!:?[->+uc*a+af~>^b+ub+k                
              +i?:fn>+b+kb^+>kn?+ii/kb++u>?a+^+?+u>u?c+             
            i:+~/+>++:kba+~b?+:>+rr!b+k+++u?n<k!b**<i<c~i           
          <!^<<<<krb~^/]>>-u~/*-:<ck^<++!!:n+!kcbinc[~kr-:          
         *k:!kb?>c~>>*u!nnrbabi>+irn>i?+~+?>icc*+ci+i+!<<rb         
        ^knnb<!<!i<b^r<i!^/]>f/>>a/?>i~>~>>>b--.r/rucffa!/<n        
        <:u<?ua<cr<*:<i:bb<fu/nb.>b:r:*?**>n:!>::~/*+.>>r-:.:       
 ...

1
2
3
4
5
6
7
8
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
9
import std.stdio;
 
void main(string[] args)
{
        int n1 = 0;
        long n2 = 0;
        
        test(n1);
        test(n2);
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
struct A {
  ulong a;
  ulong m() const {
    return a;
  }
}
 ...

1
2
3
4
5
6
struct A {
  ulong a;
  ulong m() const {
    return a;
  }
}

1
2
3
4
5
6
7
8
9
module test;
 
import std.stdio;
import std.regex;
 
string unescapePath1(string path)
{
    char[] res;
    res.reserve(path.length);
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.stdio;
import std.regex;
 
string unescapePath1(string path)
{
    // todo: replace with .reserve
    char[] res = (new char[path.length])[0..0];
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.stdio;
import std.regex;
 
string unescapePath1(string path)
{
    // todo: replace with .reserve
    char[] res = (new char[path.length])[0..0];
 ...

1
2
3
4
5
6
7
8
9
struct A
{
    immutable int a;
 
    this(in int i)
    {
        a = i;
    }
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(int line = __LINE__, string file = __FILE__)(string arg)
{
    writeln("foo called on line ", line, ", argument: ", arg, " (in file ", file, ")");
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(int line = __LINE__, string file = __PATH__)(string arg)
{
    writeln("foo called on line ", line, ", argument: ", arg, " (in file ", file, ")");
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(int line = __LINE__, string file = __FILE__)(string arg)
{
    writeln("foo called on line ", line, ", argument: ", arg, " (in file ", file, ")");
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void foo(int line = __LINE__)(string arg)
{
    writeln("foo called on line ", line, ", argument: ", arg);
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
void foo(int line = __LINE__)(string arg)
{
    writeln("foo called on line ", line, ", argument: ", arg);
}
 
void main()
{
    foo("hello world");
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
void foo(T...)(T args) { foreach (arg; args) writeln(arg); }
 
void main()
{
    foo("foobar", 5, 3.14f, [5,10,15], ["foo":5, "bar":10]);
}

1
2
3
4
5
6
7
8
import std.algorithm;
 
static assert(__traits(compiles,
{
        static assert(std.algorithm.indexOf("abcde", 'b') == 1);
}));
 
import std.string;
 ...