void main()
{
    import std.range, std.stdio;

    auto sum = 0.0;
    auto count = stdin
        //Get an input range set up to read one line at a time
        .byLine
        //Perform a transparent operation (as in the shell command tee)
        .tee!(l => sum += l.length)
        .walkLength;

    writeln("Average line length: ",
        count ? sum / count : 0);
}

import std.algorithm, std.conv, std.functional,
    std.math, std.regex, std.stdio;

alias round = pipe!(to!real, std.math.round, to!string);
static reFloatingPoint = ctRegex!`[0-9]+\.[0-9]+`;

void main()
{
    // Replace anything that looks like a real
    // number with the rounded equivalent.
    stdin
        .byLine
        .map!(l => l.replaceAll!(c => c.hit.round)
                                (reFloatingPoint))
        .each!writeln;
}

import std.stdio, std.array, std.algorithm;

void main()
{
    stdin
        .byLineCopy
        .array
        .sort!((a, b) => a > b) // descending order
        .each!writeln;
}

void main()
{
    import std.algorithm, std.stdio;

    "Starting program".writeln;

    enum a = [ 3, 1, 2, 4, 0 ];
    // Sort data at compile-time
    static immutable b = sort(a);

    // Print the result _during_ compilation
    pragma(msg, "Finished compilation: ", b);
}

void main()
{
    import std.exception, std.stdio, std.process;

    auto result = ["whoami"].execute;
    enforce(result.status == 0);
    result.output.write;
}

void main()
{
    import std.algorithm, std.stdio, std.file, std.range;
    enum cols = 14;
    // Split file into 14-byte chunks per row
    thisExePath.File("rb").byChunk(cols).take(20).each!(chunk =>
        // Use range formatting to format the
        // hexadecimal part and align the text part
        writefln!"%(%02X %)%*s  %s"(
            chunk,
            3 * (cols - chunk.length), "", // Padding
            chunk.map!(c => // Replace non-printable
                c < 0x20 || c > 0x7E ? '.' : char(c))));
}

void main()
{
    import std.datetime.stopwatch : benchmark;
    import std.math, std.parallelism, std.stdio;

    auto logs = new double[100_000];
    auto bm = benchmark!({
        foreach (i, ref elem; logs)
            elem = log(1.0 + i);
    }, {
        foreach (i, ref elem; logs.parallel)
            elem = log(1.0 + i);
    })(100); // number of executions of each tested function
    writefln("Linear init: %s msecs", bm[0].total!"msecs");
    writefln("Parallel init: %s msecs", bm[1].total!"msecs");
}

void main()
{
    import std.stdio : writefln;
    import std.algorithm.sorting : sort;
    import std.range : chain;

    int[] arr1 = [4, 9, 7];
    int[] arr2 = [5, 2, 1, 10];
    int[] arr3 = [6, 8, 3];
    // @nogc functions are guaranteed by the compiler
    // to be without any GC allocation
    () @nogc {
        sort(chain(arr1, arr2, arr3));
    }();
    writefln("%s\n%s\n%s\n", arr1, arr2, arr3);
}

void main()
{
    import std.stdio : writefln;
    int[char[2]] aa;
    auto arr = "ABBBA";

    // Iterate over all pairs in the string and observe each pair
    // ('A', 'B'), ('B', 'B'), ('B', 'A'), ...
    // String slicing doesn't allocate a copy
    foreach (i; 0 .. arr.length - 1)
        aa[arr[i .. $][0 .. 2]]++;

    foreach (key, value; aa)
        writefln("key: %s, value: %d", key, value);
}

void main()
{
    import std.stdio, std.string, std.algorithm, std.conv;

    // Reduce the RPN expression using a stack
    readln.split.fold!((stack, op)
    {
        switch (op)
        {
            // Generate operator switch cases statically
            static foreach (c; "+-*/")
                case [c]:
                    return stack[0 .. $ - 2] ~
                        mixin("stack[$ - 2] " ~ c ~
                            " stack[$ - 1]");
            default: return stack ~ op.to!real;
        }
    })((real[]).init).writeln;
}

struct Point
{
    private double[2] p;
    // Forward all undefined symbols to p
    alias p this;
    double dot(Point rhs)
    {
        return p[0] * rhs.p[0] + p[1] * rhs.p[1];
    }
}
void main()
{
    import std.stdio : writeln;
    // Point behaves like a `double[2]` ...
    Point p1, p2; p1 = [2, 1], p2 = [1, 1];
    assert(p1[$ - 1] == 1);
    // ... but with extended functionality
    writeln("p1 dot p2 = ", p1.dot(p2));
}