// Estimate π using random integers
void main()
{
    import std.stdio, std.random, std.math, std.conv;
    ulong gcd(ulong a, ulong b)
    {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
    Mt19937_64 gen; gen.seed(unpredictableSeed!ulong);
    int pairCount = 1_000_000;
    int coprimeCount = 0;
    ulong a, b;
    for (int i = 0; i < pairCount; i++) {
        a = gen.front; gen.popFront();
        b = gen.front; gen.popFront();
        if (gcd(a, b) == 1) coprimeCount++;
    }
    double prob = coprimeCount.to!double / pairCount.to!double;
    writefln("π ≈ %.15f", sqrt(6.0 / prob));
}

On Tuesday, 27 April 2021 at 21:04:19 UTC, Jeff Pratt wrote:

// Estimate π using random integers
void main()
{
    import std.stdio, std.random, std.math, std.conv;
    ulong gcd(ulong a, ulong b)
    {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
    Mt19937_64 gen; gen.seed(unpredictableSeed!ulong);
    int pairCount = 1_000_000;
    int coprimeCount = 0;
    ulong a, b;
    for (int i = 0; i < pairCount; i++) {
        a = gen.front; gen.popFront();
        b = gen.front; gen.popFront();
        if (gcd(a, b) == 1) coprimeCount++;
    }
    double prob = coprimeCount.to!double / pairCount.to!double;
    writefln("π ≈ %.15f", sqrt(6.0 / prob));
}

Nice example! A couple small improvements:

• You can use std.numeric.gcd instead of writing your own.
• You can use a foreach loop instead of a for loop.

// Estimate π using random integers
void main()
{
    import std.stdio, std.random, std.math, std.conv, std.numeric;
    Mt19937_64 gen; gen.seed(unpredictableSeed!ulong);
    int pairCount = 1_000_000;
    int coprimeCount = 0;
    ulong a, b;
    foreach (int i; 0 .. pairCount) {
        a = gen.front; gen.popFront();
        b = gen.front; gen.popFront();
        if (gcd(a, b) == 1) coprimeCount++;
    }
    double prob = coprimeCount.to!double / pairCount.to!double;
    writefln("π ≈ %.15f", sqrt(6.0 / prob));
}

On Wednesday, 28 April 2021 at 07:56:50 UTC, drug wrote:

        .map!((a)=>(gcd(a[0], a[1]) == 1) ? 1 : 0)
        .sum(0);

Alternatively:

.filter!(pair => gcd(pair[0], pair[1]) == 1)
.count;

On Wednesday, 28 April 2021 at 12:34:51 UTC, Paul Backus wrote:

        .map!((a)=>(gcd(a[0], a[1]) == 1) ? 1 : 0)
        .sum(0);

.filter!(pair => gcd(pair[0], pair[1]) == 1)
.count;

.filter!(pair => pair.expand.gcd == 1)

Not sure if it's trolly or more elegant.

On Thursday, 29 April 2021 at 14:33:06 UTC, Q. Schroll wrote:

.filter!(pair => pair.expand.gcd == 1)

I fear that new users might already be swamped with functional style and won't understand what's going on here. (But nice anyway.)

On Thursday, 29 April 2021 at 15:53:43 UTC, Berni44 wrote:

I think the range-based functional style of D is overrepresented.

When I first landed on the homepage, I saw the "Sort lines" example which scared me off. It looked totally unfamiliar, I thought D was more akin to Scala/Haskell than the Java/C-like languages I was most familiar with. Only later did I figure out that D really is a newer C/C++ like the name implies, and the range programming is just Phobos acting on top of it.

In all the examples, there is not a single if/do/while/for statement, not a single class or interface declaration, and only 1 struct declaration. I think it wouldn't hurt to have examples showing boring/traditional code in D syntax in addition to the fancy, 'code-golfy' programs.