d自动创建元组

原文

module test;

import std.stdio : writeln;
import std.range : iota, isForwardRange, hasSlicing, hasLength, isInfinite;
import std.array : array, Appender;
import std.random : Random, unpredictableSeed, dice, choice;
import std.algorithm : map, uniq, canFind;

@safe:

Random rnd;

static this()
{
  rnd = Random(unpredictableSeed);
}

void main()
{
    int recordsNeeded = 2;
    int boolValuesNeeded = 3;

    uint[] uniqueIDs;
    makeUniqueIDs(uniqueIDs, recordsNeeded);

    uint[][] tuples;
    createBoolMatrix(tuples, recordsNeeded, boolValuesNeeded);

    uint[][uint][] records = CreateTupleDictionary(uniqueIDs, tuples);
    processRecords(records);

}

auto CreateTupleDictionary(ref uint[] ids, ref uint[][] tuples)
{
    uint[][uint][] records;

    foreach(i, id; ids)
        records ~= [ ids[i] : tuples[i] ];

    return records.dup;
}

void processRecords(T)(const ref T t) if (isForwardRange!T && hasSlicing!T && hasLength!T && !isInfinite!T)
{
    t.writeln;

    // output from above should look like this:
    // [[999583661:[1, 1, 0]], [999273256:[1, 1, 1]]]

    // hoping to explore parallel here too...
}

void createBoolMatrix(ref uint[][] m, size_t numberOfTuples, size_t numberOfBoolsInTuple)
{
    m = iota(numberOfTuples)
            .map!(i => iota(numberOfBoolsInTuple)
            .map!(numberOfBoolsInTuple => cast(uint) rnd.dice(0.6, 1.4))
            .array).array;
}


void makeUniqueIDs(ref uint[] arr, size_t sz)
{
    arr.reserve(sz);

    // id needs to be 9 digits, and needs to start with 999
    int[] a = iota(999_000_000, 1_000_000_000).array;
    // above will contain 1_000_000 records that we can choose from.

    int i = 0;
    uint x;
    while(i != sz)
    {
       x = cast(uint)a.choice(rnd);

       // ensure every id added is unique.
       if (!arr.canFind(x))
       {
           arr ~= x;
           i++;
       }
    }
}