Programming-Idioms.org

writeln("Hello world!");

pragma(msg, "Hello World");

foreach(i; 0..10)
  writeln("Hello");

iota(0,10).each!(a => "Hello".writeln);

void finish() {
	writeln("I' m a done job");
}

int square(int x) {
   return x*x;
}

alias fun = (in a){return a * a;};

struct Point{
    double x;
    double y;
}

    

class Point
{
    float x;
    float y;
}

foreach(x; items) {
	doSomethingWith(x);
}

items.each!(a => writeln(a))();

foreach(i, x; items)
{
   writefln("%s: %s", i, x);
}

items.enumerate.each!(a => writeln("i = ", a[0], " value = ", a[1]));

int[string] x = ["one": 1, "two": 2];

struct BinaryTree(T)
{
	T data;
	BinaryTree* left;
	BinaryTree* right;
}

randomShuffle(x);

x.randomSample(1);

bool here = canFind(items, x);

int[string] mymap = ["Hello":1 , "World":2];
foreach (k, v; mymap)
    writeln("Key: ", k, " Value: ", v);

real pick(real _a, real _b){
    return uniform(_a, _b);
}

auto x1 = uniform(a, b+1);
auto x2 = uniform!"[]"(a, b);

void btTraversal(T)(BinaryTree!T bt, void function(T) f) {
    if (bt.left)
        btTraversal(*(bt.left), f);

    f(bt.data);

    if (bt.right)
        btTraversal(*(bt.right), f);
}

struct Node(T){
    Node[] children;
    T data;
}

alias TreeOfIntegers = Node!(int);

void prefixOrderTraversal(alias f)(ref Tree tree)
{
	f(tree);
	foreach (child; tree.children)
		prefixOrderTraversal!f(child);
}

reverse(x);

auto y = x.retro;

auto search(int[][] m, int x)
{
	foreach (i, row; m)
	{
		foreach (j, cell; row)
		{
			if (cell == x)
				return tuple(i, j);
		}
	}
}

auto temp = a;
a = b;
b = temp;

swap(a,b);

auto i = s.to!int;

string str = format("%.2s", x);

string s = "ネコ";

auto t = spawn( {
   receive( (string s) { writefln("Hello, %s", s); } );
} );

t.send("Alan");

auto x = new double[][](m, n);

auto x = new real[][][](m, n, p);

sort!("a.p < b.p")(items);

items = items.remove(i);

taskPool.amap!f(iota(1, 1001));

uint f(in uint i) pure nothrow @nogc
in {
    assert(i <= 12);
} body {
    if (i == 0)
        return 1;
    else
        return i * f(i - 1);
}

uint exp(uint x, uint n) {
    if(n == 0)
        return 1;
    if(n == 1)
        return x;
    if(n % 2 == 0)
        return exp(x * x, n / 2);
    else
        return x * exp(x * x, (n - 1) / 2);
}

synchronized x = f(x);

auto x = redBlackTree!T;

auto compose(f, g) {
	return std.functional.compose!(f, g);
}

auto _compose(T)(T function(T) f, T function(T) g)
{
    auto lambda = (T x) { return g(f(x));  };
    return lambda;
}

int add(int n1, int n2)
{
    return n1 + n2;
}

alias add5 = curry!(add, 5);

auto t = s[i .. j];

bool ok = s.canFind(word);

struct Vertex
{
	float x, y, z;
	Vertex* [] adjacentVertices;
}

auto t = s.retro.array;

auto a = [1,2,3,4,5];
auto b = [3,5];

void main()
{
mainloop:
	foreach(v;  a){
		foreach(w; b){
			if(v == w) continue mainloop;
		}
		writeln(v);		 
	}
}

outer:
foreach (i; 0 .. m.length)
{
	foreach (j; 0 .. m[i].length)
	{
		if (m[i][j] < 0)
		{
			writeln(m[i][j]);
			break outer;
		}
	}
}

s.insertInPlace(i, x);

Thread.sleep(5.seconds);

string t = s[0..5];

string t = s[$-5..$];

auto s = "One,
Two,
Three
";

auto s = `line1
line2
line3`;

auto s = r"line1
line2
line3";

auto chunks = s.splitter;

while (true) { }

for (;;) {}

if (k in m) { }

m.byValue.canFind(v);

string y = x.join(", ");

auto s = x.sum();

string s = i.to!string;

foreach(i; parallel(iota(1,1001))){
	f(i);
}
writeln("Finished");

auto y = [1, 2, 3, 4, 5].filter!(a => a%2==0);

auto y = x.filter!(p);

string lines = cast(string) read(f, size_t.max);

auto lines = f.readText;

stderr.writeln(x, " is negative");

auto x = args[1];

auto d = Clock.currTime;

auto i = x.countUntil(y);

auto x2 = x.replace(y,z);  

BigInt x = BigInt(3);
x ^^= 247;

string percent = format("%.1f%%", x * 100.0);

BigInt z = x ^^ n;

BigInt binom(uint n, uint k)
{
   assert(n >= k);
   BigInt r = 1;
   for(uint i = 0; i <= k; ++i)
   {
      r *= n-i;
      r /= i+1;
   }
   return r;
}

BitArray x;
x.length = n;

auto s = 8;
auto gen = Random(s);
writeln(gen.front);

auto rng = Random(cast(uint)Clock.currTime.stdTime);

rndGen.seed(cast(uint)Clock.currTime.stdTime);

void main(string[] args)
{
	args[1..$].join(" ").writeln;
}

void main(string[] args)
{
	writeln(args.dropOne.joiner(" "));
}

auto fact(T, A...)(A a)
if (is(T==class) && is(T: Parent))
{
    return new T(a);
}

x = gcd(a, b);

BigInt gcd(in BigInt x, in BigInt y) pure {
    if (y == 0)
        return x;
    return gcd(y, x%y);
}

gcd(a, b);

uint x = (a * b) / gcd(a, b);

auto s = to!string(x,2);

auto x = complex(-2, 3);
x * complex(0, 1);

do
{
    something;
    somethingElse;
}
while (c);

int x;
float y = to!float(x);
// or
float y = cast(float) x;

int y = cast(int)x;

int y = cast(int) x.round;

auto occurrences = s.count(t);

auto r = regex("htt+p");

auto c = bitSet(i).length;

bool addingWillOverflow(int x, int y)
{
    bool result;
    core.checkedint.adds(x, y, result);
    return result;
}

bool multiplyWillOverflow(int x, int y)
{
    bool result;
    core.checkedint.muls(x, y, result);
    return result;
}

exit(0);

void[] buf = malloc(1024 * 1024)[0..1024 * 1024];

void[] buf = GC.malloc(1024 * 1024)[0..1024 * 1024];

throw new Exception("invalid value for x (%s) in '%s'".format(x, __PRETTY_FUNCTION__));

void foo(int x)
in
{
    assert(x != 0, "wrong value for x");
}
body
{
    // function
}

struct Foo
{
    private int _x;
    int x() {return _x;}
}

JSONValue x = "data.json".readText.parseJSON;

struct User {
    int age;
    string name;

    this(JSONValue user) {
        age  = user["age"];
        name = user["name"];
    }
}

auto user = User(x);

auto x = JSONValue(["age":42, "name":"Bob"]);
"data.json".write(x.toJSON);

void control(alias f)()
if (isCallable!f)
{
    f();
}

void control(void function() f)
{
    f();
}

writeln(typeid(x));

auto x = getSize(path);

b = s.startsWith(prefix);

b = s.endsWith(suffix);

auto d = SysTime(unixTimeToStdTime(ts), UTC());

string x = Date(1993, 10, 26).toISOExtString;

items.sort!c;

string s = u.get.to!string;

download(u, "result.txt");

XmlArchive archive = new XmlArchive!(char);
archive.doc.parse(read("data.xml"));
Serializer ser = new Serializer(archive);
ser.deserialize(x);

auto archive = new XmlArchive!(char);
auto serializer = new Serializer(archive); 
serializer.serialize(x);
write("data.xml", archive.data);

void main(string[] args) {
    string s = args[0].baseName;
}

string dir = absolutePath;

void main(string[] args) {
    string dir = args[0].dirName;
}

int x = 42;

void printIfDefined(alias name)()
{
    import std.stdio: writeln;
    static if( __traits(compiles, writeln(mixin(name))))
        writeln(mixin(name));
}

void main(string[] args)
{
    printIfDefined!"x";
    printIfDefined!"Foo.bar";
}

static if (is(typeof(x = x.init)))
    writeln(x);

auto n = T.sizeof;

bool blank = s.all!isSpace;

spawnProcess([x, "a", "b"]);

mymap.byKeyValue
     .array
     .sort!((a, b) => a.key < b.key)
     .each!(p => writeln(p.key, " ", p.value));

mymap.byKeyValue
     .array
     .sort!((a, b) => a.value < b.value)
     .each!(p => writeln(p.key, " ", p.value));

b = deeplyEqual(x, y));

bool b = d1 < d2;

auto s2 = s1.replace(w, "");

auto n = x.length;

n = walkLength(x);

bool[typeof(x[0])] y;

foreach (e ; x)
    y[e] = true;

auto y = redBlackTree(x);

x = x.sort.uniq.array;

x = redBlackTree(x)[].array;

readf("%d", &n);

ubyte[1024] b;

auto sock = new UdpSocket();
scope(exit) sock.close;

sock.bind(new InternetAddress(p));
sock.receive(b);

enum Suit{
  SPADES,
  HEARTS,
  DIAMONDS,
  CLUBS
}

assert(isConsistent);

long binarySearch(long[] a, long x) {
    long result = a.assumeSorted.lowerBound(x).length;
    if (result == a.length || a[result] != x)
        return -1;
    return result;
}

StopWatch sw;
sw.start;
foo;
auto t = sw.peek.nsecs; 
writeln(t);

auto foo()
{
    return tuple("theString", true);
}

void foo()
{
    mixin(import("foobody.txt"));
}

if      (c1) f1;
else if (c2) f2;
else if (c3) f3;

auto elapsed = benchmark!f(1)[0].msecs;

{
    import std.stdio;
    auto mt = measureTime!((TickDuration a{writeln(a.msecs);});
    f();
}

StopWatch sw;
sw.start;
f();
auto elapsed = sw.peek;

ok = indexOf(word, s, CaseSensitive.no) != -1;

auto items = [a, b, c];

items = items.remove(items.countUntil!(a => a == x));

items = items.filter!(a => a != x).array;

bool b = s.filter!(a => !isDigit(a)).empty;

bool b = s.all!isDigit;

auto f = File.tmpfile();

string mkTmpDir()
{
    import std.uuid, std.file, std.path;
    string d = buildPath(tempDir, randomUUID.toString);
    if (!d.exists)
    {
        mkdir(d);
        return d;
    }
    else return null;
}

string s;
while (!s.length)
  s = mkTmpDir;

m.remove(k);

chain(items1, items2).each!writeln;

s = to!string(x, 16);

s = format("%x", x);

roundRobin(items1, items2).each!writeln;

bool b = fp.exists;

log(msg);

float f = s.to!float;

auto t = s.filter!(a => a.isASCII).array;

auto list = stdin.byLine.map!(a => a.to!int);

auto p = "no_more_slashes///".stripRight!(a => a == '/');
writeln(p); // no_more_slashes

p=p.chomp("/");

p = p.chomp(dirSeparator);

string s = to!string(c);

string t = s ~ to!string(i);

string t = "%s%d".format(s, i);

string c = roundRobin(c1.dropOne.chunks(2), c2.dropOne.chunks(2))
    .map!(a => a.to!int(16)).array
    .chunks(2)
    .map!(a => ((a[0] + a[1]) / 2))
    .fold!((a,b) => a ~= "%.2X".format(b))("#");

try
    remove(filepath);
catch (FileException fe)
    writeln(fe.msg);

string s = format("%03d", i);

const string planet = "Earth";

immutable string planet = "Earth";

static immutable string planet = "Earth";

enum planet = "Earth";

enum string planet = "Earth";

auto y = randomSample(x, k);

struct Trie
{
    Rune c;
    Trie*[Rune] children;
    bool isEntry;
    bool value;
}

version(X86)
    f32();
version(X86_64)
    f64();

static if (size_t.sizeof == 4)
    f32();
static if (size_t.sizeof == 8)
    f64();

elements[] *= c;

void main(string[] args)
{
    void bat(){} void fox(){}
    getopt(args, "b", &bat, "f", &fox);
}

list.chunks(2).each!writeln;

browse(s);

int[42] items;
int x = items[$-1];

int[] items;
auto x = items.back();

int[] a, b;
auto ab = a ~ b;

int[] a, b;
auto ab = chain(a, b);

string t = s.chompPrefix(p);

string t = s.chomp(w);

size_t n = s.length;

size_t n = s.walkLength;

size_t n = s.byGrapheme.walkLength;

const n = mymap.length;

s ~= x;

m[k] = v;

string f = "%3,d".format(123456);

auto response = post(u, content);

s = a.toHexString;

ubyte[] a = s.chunks(2)
             .map!(digits => digits.to!ubyte)
             .array;

ubyte[] a = cast(ubyte[]) hexString!s.representation;

immutable exts = ["jpg", "jpeg", "png"];
auto L = D.dirEntries(SpanMode.depth)
          .map!(to!string)
          .filter!(f => exts.canFind(f.split(".")[$-1]));

bool b = x1<x && x<x2 && y1<y && y<y2;

auto c = tuple((x1+x2)/2, (y1+y2)/2);

auto x = dirEntries(d, SpanMode.shallow);

y = x.filter!(P).map!(T);

void foo(Range)(Range r) {
	r.fill(42);
}

foo(a.indexed(iota(0,m,2)));

string foo = environment.get("FOO", "none");

auto value = tuple(5, 6.7, "hello");

auto entry = tuple!("index", "value", "active")(4, "Hello", true);

items = x ~ items;

x = condition()? "a": "b";