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

Question

下面是我不想复制的迭代器：

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,2,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添加到参数并返回。但这使得它不再适用于上述非变量情况。

据我所知，这个问题相当于做以下工作：

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,2,3]
for i in testI[var seq[int], var int](lst):
  i += 1

在D编程语言中，有这样的'auto‘参数，这些参数根据它们是否是lvalue而选择为引用参数或值参数。

为何这是一个很难解决的问题？我不想每次做迭代器时都要复制粘贴函数。

Answer 1

通常在Nim中您会发现两个迭代器：items和mitems，一个用于获取项而不是修改它们，另一个用于允许修改。在尝试实现一些疯狂的东西之前，我会努力使用这些程序。

但是有时您必须实现它，所以每当您发现自己在Nim中遇到“代码重复”问题时，可以用Ctrl来解决，您应该在“模板”中进行思考。例如。

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,2,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, 2, 3]
for i in testI(lst):
  i += 1

echo lst
# @[2, 3, 4]

这是在mitems for openArrays中定义的代码(已经通过system导入到您的代码中)，因此可以将上面的代码重写为：

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

echo lst
# @[2, 3, 4]