void main()
{
    // Define an array of numbers, double[].
    // Compiler recognizes the common
    // type of all initializers.
    auto arr = [ 1, 2, 3.14, 5.1, 6 ];
    // Dictionary that maps string to int,
    // type is spelled int[string]
    auto dictionary = [ "one" : 1, "two" : 2,
        "three" : 3 ];
    // Calls the min function defined below
    auto x = min(arr[0], dictionary["two"]);
}
// Type deduction works for function results.
// This is important for generic functions,
// such as min below, which works correctly
// for all comparable types.
auto min(T1, T2)(T1 lhs, T2 rhs)
{
    return rhs < lhs ? rhs : lhs;
}

import std.stdio;

class Widget { }

void main()
{
    // Automatically managed.
    auto w = new Widget;
    // Code is executed in any case upon scope exit.
    scope(exit) { writeln("Exiting main."); }
    // File is closed deterministically at scope's end.
    foreach (line; File("text.txt").byLine())
    {
        writeln(line);
    }
    writeln();
}

#!/usr/bin/env rdmd
import std.range, std.stdio;

// Compute average line length for stdin
void main()
{
    ulong lines = 0, sumLength = 0;
    foreach (line; stdin.byLine())
    {
        ++lines;
        sumLength += line.length;
    }
    writeln("Average line length: ",
        lines ? cast(double) sumLength / lines : 0.0);
}

// Interfaces and classes
interface Printable
{
   void print(uint level)
   // contract is part of the interface
   in { assert(level > 0); }
}

// Interface implementation
class Widget : Printable
{
   void print(uint level)
   in{ }
   body{ }
}

// Single inheritance of state
class ExtendedWidget : Widget
{
   override void print(uint level)
   in { /* weakening precondition is okay */  }
   body
   {
       //... level may be 0 here ...
   }
}

// Immutable data shared across threads
immutable string programName = "demo";
// Mutable data is thread-local
int perThread = 42;
// Explicitly shared data
shared int perApp = 5;

// Structs have value semantics
struct BigNum
{
    // intercept copying
    this(this) { }
    // intercept destructor
    ~this() { }
}

void main()
{
    // ...
}

import core.stdc.stdlib;

void livingDangerously()
{
    // Access to C's malloc and free primitives
    auto buf = malloc(1024 * 1024);
    // free automatically upon scope exit
    scope(exit) free(buf);
    // Interprets memory as an array of floats
    auto floats = cast(float[]) buf[0 .. 1024 * 1024];
    // Even stack allocation is possible
    auto moreBuf = alloca(4096 * 100);
    //...
}

// Using inline asm for extra speed on x86
uint checked_multiply(uint x, uint y)
{
    uint result;
    version (D_InlineAsm_X86)
    {
        // Inline assembler "sees" D variables.
        asm
        {
            mov     EAX,x        ;
            mul     EAX,y        ;
            mov     result,EAX   ;
            jc      Loverflow    ;
        }
        return result;
    }
    else
    {
        result = x * y;
        if (!y || x <= uint.max / y)
           return result;
   }
Loverflow:
   throw new Exception("multiply overflow");
}

void main()
{
    // ...
}