可变参数的解构迭代，如 D 中的元组序列

Question

假设我想处理一个可变参数函数，它交替传递 1 个或多个间隔的开始值和结束值，它应该 return 这些间隔中的一系列随机值。您可以将输入想象成一个扁平的元组序列，所有元组元素都分布在一个范围内。

import std.meta; //variadic template predicates
import std.traits : isFloatingPoint;
import std.range;

auto randomIntervals(T = U[0], U...)(U intervals)
if (U.length/2 > 0 && isFloatingPoint!T && NoDuplicates!U.length == 1) {
    import std.random : uniform01;
    
    T[U.length/2] randomValues;
    // split and iterate over subranges of size 2
    foreach(i, T start, T end; intervals.chunks(2)) {   //= intervals.slide(2,2)
        randomValues[i] = uniform01 * (end - start) + start,
    }
    return randomValues.dup;
}

例子不重要，我只是用来解释。块大小可以是任何有限的正数 size_t，而不仅仅是 2，并且更改块大小应该只需要更改 foreach 循环中的循环变量的数量。

在上面的这种形式中，它不会编译，因为它只需要 foreach 循环的一个参数（一个范围）。我想要的是自动使用或推断滑动 window 作为元组的东西，从给定循环变量的数量派生，并用 range/array 的下一个元素填充附加变量 +允许附加索引，可选。根据 documentation 元组范围允许将元组元素分解uring 到 foreach-loop-variables 所以我想到的第一件事就是把一个range 成一个元组序列，但没有找到一个方便的函数。

是否有一种简单的方法来遍历解构的子范围（如我的示例代码所示那样简单）以及索引？或者是否有一个（标准库）函数来完成将范围拆分为大小相等的枚举元组的工作？如何轻松地将子范围的范围变成元组的范围？

在这种情况下 std.algorithm.iteration.map 是否可行（编辑：使用一个简单的函数参数映射而不访问元组元素）？

编辑：我想忽略不适合整个元组的最后一个块。它只是没有迭代。

编辑：不是的，我不能自己编程，我只希望有一个简单的符号，因为这个循环多个元素的用例非常有用。如果 D 中有像 JavaScript 中的“展开”或“休息”运算符之类的东西，请告诉我！

谢谢。

Answer 1

chunks 和 slide return Ranges，不是元组。它们的最后一个元素可以包含小于指定的大小，而元组具有固定的编译时大小。

如果你需要解构，你必须实现你自己的 chunks/slide 那 return 元组。要向元组显式添加索引，请使用 enumerate。这是一个例子：

import std.typecons, std.stdio, std.range;

Tuple!(int, int)[] pairs(){
    return [
        tuple(1, 3),
        tuple(2, 4),
        tuple(3, 5)
    ];
}

void main(){
    foreach(size_t i, int start, int end; pairs.enumerate){
        writeln(i, ' ', start, ' ', end);
    }
}

编辑：

正如 BioTronic 所说，使用 map 也是可能的：

foreach(i, start, end; intervals
                       .chunks(2)
                       .map!(a => tuple(a[0], a[1]))
                       .enumerate){

Answer 2

你的问题让我有些疑惑，如果我理解有误，请见谅。您基本上要问的是 foreach(a, b; [1,2,3,4].chunks(2)) 是否可行，对吗？

如您所说，这里的简单解决方案是 map 从块到 tuple:

import std.typecons : tuple;
import std.algorithm : map;
import std.range : chunks;
import std.stdio : writeln;

unittest {
    pragma(msg, typeof([1,2].chunks(2).front));

    foreach(a, b; [1,2,3,4].chunks(2).map!(a => tuple(a[0], a[1]))) {
        writeln(a, ", ", b);
    }
}

Answer 3

（添加为单独的答案，因为它与我之前的答案有很大不同，不适合发表评论）

到目前为止，在阅读了您的评论和对答案的讨论之后，在我看来，您寻求的是类似于下面的 staticChunks 函数：


unittest {
    import std.range : enumerate;
    size_t index = 0;
    foreach (i, a, b, c; [1,2,3,1,2,3].staticChunks!3.enumerate) {
        assert(a == 1);
        assert(b == 2);
        assert(c == 3);
        assert(i == index);
        ++index;
    }
}

import std.range : isInputRange;

auto staticChunks(size_t n, R)(R r) if (isInputRange!R) {
    import std.range : chunks;
    import std.algorithm : map, filter;
    return r.chunks(n).filter!(a => a.length == n).map!(a => a.tuplify!n);
}


auto tuplify(size_t n, R)(R r) if (isInputRange!R) {
    import std.meta : Repeat;
    import std.range : ElementType;
    import std.typecons : Tuple;
    import std.array : front, popFront, empty;
    
    Tuple!(Repeat!(n, ElementType!R)) result;

    static foreach (i; 0..n) {
        result[i] = r.front;
        r.popFront();
    }
    assert(r.empty);

    return result;
}

请注意，这也处理了最后一个大小不同的块，如果只是默默地把它扔掉的话。如果这种行为是不可取的，请删除 filter，并在 tuplify 中处理它（或者不这样做，并观察异常情况）。

Answer 4

在使用 BioTronic 的同时，我尝试编写一些自己的解决方案来解决这个问题（在 DMD 上测试）。我的解决方案适用于切片（但不适用于固定大小的数组）并避免调用 filter:

import std.range : chunks, isInputRange, enumerate;
import std.range : isRandomAccessRange; //changed from "hasSlicing" to "isRandomAccessRange" thanks to BioTronics
import std.traits : isIterable;

/** turns chunks into tuples */
template byTuples(size_t N, M)
if (isRandomAccessRange!M) {   //EDITED
    import std.meta : Repeat;
    import std.typecons : Tuple;
    import std.traits : ForeachType;

    alias VariableGroup = Tuple!(Repeat!(N, ForeachType!M));    //Tuple of N repititions of M's Foreach-iterated Type
    /** turns N consecutive array elements into a Variable Group */
    auto toTuple (Chunk)(Chunk subArray) @nogc @safe pure nothrow
    if (isInputRange!Chunk) {       //Chunk must be indexable
        VariableGroup nextLoopVariables;    //fill the tuple with static foreach loop
        static foreach(index; 0 .. N) {
            static if ( isRandomAccessRange!Chunk ) {  // add cases for other ranges here
                nextLoopVariables[index] = subArray[index];
            } else {
                nextLoopVariables[index] = subArray.popFront();
            }
        }
        return nextLoopVariables;
    }
    /** returns a range of VariableGroups */
    auto byTuples(M array) @safe pure nothrow {
        import std.algorithm.iteration : map;

        static if(!isInputRange!M) {
            static assert(0, "Cannot call map() on fixed-size array.");
//          auto varGroups = array[].chunks(N);     //fixed-size arrays aren't slices by default and cannot be treated like ranges
            //WARNING! invoking "map" on a chunk range from fixed-size array will fail and access wrong memory with no warning or exception despite @safe!
        } else {
            auto varGroups = array.chunks(N);
        }
        //remove last group if incomplete
        if (varGroups.back.length < N) varGroups.popBack();
        //NOTE! I don't know why but `map!toTuple` DOES NOT COMPILE! And will cause a template compilation mess.
        return varGroups.map!(chunk => toTuple(chunk));     //don't know if it uses GC
    }
}

void main() {
    testArrayToTuples([1, 3, 2, 4, 5, 7, 9]);
}

// Order of template parameters is relevant.
// You must define parameters implicitly at first to be associated with a template specialization
void testArrayToTuples(U : V[], V)(U arr) {

    double[] randomNumbers = new double[arr.length / 2];
    // generate random numbers
    foreach(i, double x, double y; byTuples!2(arr).enumerate ) {    //cannot use UFCS with "byTuples"
        import std.random : uniform01;
        randomNumbers[i] = (uniform01 * (y - x) + x);
    }
    foreach(n; randomNumbers) { //'n' apparently works despite shadowing a template parameter
        import std.stdio : writeln;
        writeln(n);
    }
}

使用切片运算符的逐元素运算在这里不起作用，因为 uniform01 * (ends[] - starts[]) + starts[] 中的 uniform01 只会被调用一次，不会被多次调用。

编辑：我还为此代码测试了一些 D 在线编译器，奇怪的是它们对相同代码的行为不同。对于D的编译我可以推荐

https://run.dlang.io/（如果这个不行我会很惊讶）
https://www.mycompiler.io/new/d（但有点慢）
https://ideone.com（它有效，但它使您的代码 public！不要与受保护的代码一起使用。）

但那些对我不起作用：

https://tio.run/#d2（有一次没有编译完，否则用动态数组测试也执行结果错误）
https://www.tutorialspoint.com/compile_d_online.php（不编译静态 foreach）

可变参数的解构迭代，如 D 中的元组序列

Destructured iteration over variadic arguments like a tuple sequence in D

foreach

tuples

d

variadic