迭代器的通用可变和非可变参数

如何解决迭代器的通用可变和非可变参数

这是我不想复制的迭代器：

iterator testI[T](arr: seq[T]): T =
  # I don't want to copy-paste this body
  # In a real world example it might be much bigger
  for i in 0 ..< arr.len:
    yield arr[i]

这适用于：

for i in testI(@[1,2,3]):
  echo i

但不在：

var lst = @[1,3]
for i in testI(lst):
  i += 1
  echo i

我可以将迭代器定义替换为：

iterator testI[T](arr: var seq[T]): var T =
  # I don't want to copy-paste this body
  # In a real world example it might be much bigger
  for i in 0 ..< arr.len:
    yield arr[i]

注意，我只是将var添加到参数中并返回。但这使得它不再适用于上面的non-var情况。

据我所知，这个问题等同于完成以下工作：

proc foo[A,B](x: A,fn: B) =
  fn(x)

var x = 1
foo(x,proc(x: var int) = x += 1)
foo(1,proc(x: int) = echo x)
assert x != 1

由于某种原因，这甚至不起作用：

iterator testI[A,B](arr: A): B =
  # I don't want to copy-paste this body
  # In a real world example it might be much bigger
  for i in 0 ..< arr.len:
    yield arr[i]
var lst = @[1,3]
for i in testI[var seq[int],var int](lst):
  i += 1

在D编程语言中，有诸如“自动引用”之类的参数，它们基于是否为左值而选择是引用还是值参数。

为什么这是一个难题？我不想每次创建迭代器时都必须复制粘贴该函数。

解决方法

通常在Nim中，您会找到两个迭代器：items和mitems，一个迭代器获取项目而不修改它们，另一个迭代器允许修改。在尝试实施疯狂的操作之前，我会尽力使用这些过程。

但是有时候您必须实现它，所以只要您发现自己在Nim中出现“代码重复”问题，而该问题可以通过Ctrl-C Ctrl-V解决，则应该考虑“模板”。例如

template myCycle =
  ## Long and tedious code here.
  for i in 0 ..< arr.len:
    yield arr[i]

iterator testI[T](arr: seq[T]): T =
  echo "Non-var type"
  myCycle

iterator testI[T](arr: var seq[T]): var T =
  echo "Var type"
  myCycle

var lst1 = @[1,2,3]
for i in testI(lst1):
  echo i

let lst2 = @[1,3]
for i in testI(lst2):
  echo i

编译时，Nim将为您复制myCycle中的长代码，并将其粘贴到两个迭代器中。请注意，您不必将arr传递给模板，因为它不是调用而是复制粘贴。

---

没有什么比最后一个代码块更好地说明我的第一点了。这是等效的代码：

iterator testI[T](a: var openArray[T]): var T {.inline.} =
  var i = 0
  while i < len(a):
    yield a[i]
    inc(i)

var lst = @[1,3]
for i in testI(lst):
  i += 1

echo lst
# @[2,3,4]

这是mitems中为openArrays定义的代码（已经通过system导入您的代码中），因此以上代码可以重写为：

var lst = @[1,3]
for i in mitems(lst):
  i += 1

echo lst
# @[2,4]