1
2
3
4
5
6
7
8
#!/usr/bin/env rdmd
import std.stdio;
import std.typecons;
 
struct Array(T) {
  private T[] arr;
  mixin Proxy!arr;
  this(T[] a) { arr = a; }
 ...

1
2
3
4
5
6
7
8
9
#!/usr/bin/env rdmd
import std.stdio;
import std.typecons;
 
struct Array(T) {
  private T[] arr;
  mixin Proxy!arr;
  alias arr this;
  this(T[] a) { arr = a; }
 ...

1
2
3
4
5
6
7
8
#!/usr/bin/env rdmd
import std.stdio;
import std.typecons;
 
struct Array(T) {
  private T[] arr;
  mixin Proxy!arr;
  this(T[] a) { arr = a; }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
int main () {
        immutable inches_per_feet = 12;
        immutable cm_per_inch = 2.54;
        
        foreach (feet; 5..7) {
                foreach (inches; 0..12) {
                        double cms = (inches + inches_per_feet * feet) * cm_per_inch;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
int main () {
        immutable inches_per_feet = 12;
        immutable cm_per_inch = 2.54;
        
        foreach (feet; 5..7) {
                foreach (inches; 0..12) {
                        cms = (inches + inches_per_feet * feet) * cm_per_inch;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
int main () {
        immutable inches_per_feet = 12;
        immutable cm_per_inch = 2.54;
        
        foreach (feet; 5..7) {
                foreach (inches; 0..12) {
                        cms = (inches + inches_per_feet * feet) * cm_per_inch;
 ...

1
2
3
4
5
6
7
8
9
            bool onLinkDeadMsg( ref Message msg )
            {
                assert( msg.convertsTo!(Tid) );
                auto tid = msg.get!(Tid);
 
                if( bool* depends = (tid in links) )
                {
                    links.remove( tid );
                    // Give the owner relationship precedence.
 ...

1
2
3
4
5
6
import std.compiler, std.stdio;
 
void main()
{
    writeln(version_major, ".", version_minor);
}

1
2
3
4
void main()
{
 
}

1
2
3
4
5
6
7
8
9
import std.conv;
 
template fizzbuzz(int n)
{
    static if (n == 0) {
        immutable string fizzbuzz = "";
    } else {
        immutable string fizzbuzz = fizzbuzz!(n-1) ~ (
                                                        n%15 == 0 ? "FizzBuzz" :
 ...

1
2
3
4
5
6
7
8
9
import std.string;
import std.stdio;
 
 
struct S {
        ubyte[] metadata;
        
        string toString(){
                return "%s".format( metadata );
 ...

1
2
3
4
5
6
7
8
9
import std.string;
import std.stdio;
 
 
struct S {
        ubyte[] metadata;
        
        string toString(){
                return "%s".format( metadata );
 ...

1
2
3
4
5
6
7
8
9
import std.string;
import std.stdio;
 
 
struct S {
        ubyte[] metadata;
        
        string toString(){
                return "%s".format( metadata );
 ...

1
2
3
4
5
6
7
8
9
import std.conv;
 
string fizzbuzz(int n)
{
    return n==0 ? "" : fizzbuzz(n-1) ~ ( ( n%15==0 ? "FizzBuzz\n" :
                                           n%3==0  ? "Fizz\n" :
                                           n%5==0  ? "Buzz\n" :
                                           to!string(n) ~ '\n'
                                           )
 ...

1
 

1
2
3
4
5
6
7
8
9
class Foo {
  int opApply(scope int delegate(ref int) dg)
  {
    return 0;
  }
}
class Bar {
  const Foo foo;
  void hoge() const
 ...

1
2
3
4
5
6
7
8
9
function NetSend(const sTo, sMessage: string): Boolean;
type
  PNetMessageBufferSend = ^TNetMessageBufferSend;
  TNetMessageBufferSend = function(
    servername: PWideChar;
    msgname: PWideChar;
    fromname: PWideChar;
    buf: PBYTE;
    buflen: DWORD
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
class Foo {
  int a;
  int opApply(scope int delegate(ref int) dg)const
  {
    auto r = dg(a); // なんで渡せるの？
    if (r) return r;
    return 0;
  }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
class Foo {
  int a;
  int opApply(scope int delegate(ref int) dg)const
  {
    auto r = dg(a);
    if (r) return r;
    return 0;
  }
 ...

1
2
3
4
5
6
7
8
9
class Foo {
  int opApply(scope int delegate(ref int) const dg)
  {
    return 0;
  }
}
class Bar {
  Foo foo;
  void hoge() const
 ...

1
2
3
4
5
6
7
8
9
class Foo {
  int opApply(scope int delegate(ref int) dg)
  {
    return 0;
  }
}
class Bar {
  Foo foo;
  void hoge() const
 ...

1
2
3
4
5
6
7
8
Class Vector () {
        int x;
        int y;
        this(int X, int Y) {
                x = X;
                y = Y;
        }
}
 ...

1
2
3
4
5
6
7
8
Class Vector () {
        int x;
        int y;
        this(int X, int Y) {
                this.x = X;
                this.y = Y;
        }
}
 ...

1
2
3
4
5
6
7
8
9
/* Sieve of Eratosthenes prime numbers */ 
 
import std.stdio; 
 
bool[8191] flags; 
 
int main() { 
        int i, count, prime, k, iter; 
        writefln("10 iterations"); 
 ...

1
2
3
4
5
6
7
8
9
import std.string;
import std.stdio;
 
class T{
    private:
        string _name;
    
    public:
        this( string name ){
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
bool[8191] flags;
 
int main()
{
        int count;
        writefln("10 iterations");
        for(int itr = 1; itr <= 10; ++itr){
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
bool[8191] flags;
 
int main()
{
        int count;
        writeln("10 iterations");
        for(int itr = 1; itr <= 10; ++itr){
 ...

1
2
3
4
5
6
7
8
9
import std.stdio
 
bool[8191] flags;
 
int main()
{
        int count;
        writeln("10 iterations");
        for(int itr = 1; itr <= 10; ++itr){
 ...

1
2
3
4
5
6
7
import std.stdio;
 
int main(string[] argv)
{
        writeln( "Hello World" );
        return 0;
}

1
2
3
4
5
6
7
8
9
import std.stdio, std.concurrency;
 
void foo()
{
    bool cont = true;
 
    while (cont)
    {
        receive( // delegates are used to match the message type
 ...