如何解决对可变参数的解构迭代，如 D
假设我想处理一个可变参数函数，该函数交替传递 1 个或多个间隔的开始和结束值，并且它应该返回这些间隔中的一系列随机值。您可以将输入想象成一个扁平的元组序列，所有元组元素分布在一个范围内。
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 循环。我想要的是自动使用或推断滑动窗口作为元组的东西，从给定的循环变量的数量派生，并用范围/数组的下一个元素填充附加变量+允许附加索引，可选。根据 documentation 元组范围允许将元组元素销毁为 foreach-loop-variables 所以我想到的第一件事是将范围变成一个元组序列，但没有找到一个方便的函数。
是否有一种简单的方法可以将解构的子范围（如我的示例代码所示如此简单）与索引一起循环？或者是否有一个（标准库）函数可以将范围拆分为相等大小的枚举元组？如何轻松地将子范围的范围转换为元组范围？
在这种情况下是否可以使用 std.algorithm.iteration.map（编辑：使用一个简单的函数参数来映射而不访问元组元素）？
编辑：我想忽略不适合整个元组的最后一个块。它只是没有迭代。
编辑：不是，我不能自己编程，我只希望有一个简单的符号，因为这个循环多个元素的用例非常有用。如果在 D 中像 JavaScript 一样有“传播”或“休息”运算符之类的东西，请告诉我！
谢谢。
解决方法
chunks 和 slide 返回 Range，而不是元组。它们的最后一个元素可以包含小于指定的大小，而元组具有固定的编译时大小。
如果您需要解构，则必须实现自己的返回元组的块/幻灯片。要向元组显式添加索引，请使用 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,end; intervals
.chunks(2)
.map!(a => tuple(a[0],a[1]))
.enumerate){
（作为单独的答案添加，因为它与我之前的答案明显不同，并且不适合评论）
在阅读您的评论和迄今为止对答案的讨论后，在我看来，您寻求的是类似于以下 staticChunks 函数：
unittest {
import std.range : enumerate;
size_t index = 0;
foreach (i,a,b,c; [1,2,3,1,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 内处理它（或者不要，并观察异常滚滚而来）。
你的问题让我有点困惑，所以如果我误解了，我很抱歉。您基本上要问的是 foreach(a,b; [1,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,4].chunks(2).map!(a => tuple(a[0],a[1]))) {
writeln(a,",b);
}
}
在使用 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,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 中的 uniform01 * (ends[] - starts[]) + starts[] 只会被调用一次而不是多次。
编辑：我还为此代码测试了一些 D 的在线编译器，奇怪的是它们对于相同的代码表现不同。对于 D 的编译，我可以推荐
- https://run.dlang.io/（如果这个行不通我会很惊讶）
- https://www.mycompiler.io/new/d（但有点慢）
- https://ideone.com（它可以工作，但会使您的代码公开！不要与受保护的代码一起使用。）
但那些对我不起作用：
- https://tio.run/#d2（一种情况没有完成编译，否则即使使用动态数组进行测试也执行错误）
- https://www.tutorialspoint.com/compile_d_online.php（不编译静态 foreach）
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
