[RFC] Tuple unpacking in loops/iterators

[narimiran]

Current situation

To iterate through a container, we now have:

for val in mySeq:
  ...

There is also an option to have an index too with:

for i, val in mySeq:
  ...

If mySeq is container of tuples, we currently need to do:

for val in mySeq:
  let
    x = val[0]
    y = val[1]
    z = val[2]
  ...

An example of zip usage:

for val in zip(seqA, seqB):
  let area = val.a * val.b # you must use `a` and `b`, no other letters/words

---

Proposal

My proposition is to have tuple unpacking available in loops, and to use the same syntax which is currently used for tuple unpacking in let statements: let (x, y, z) = myTuple.

The above example now looks like this:

for (x, y, z) in mySeq:
  ...

or if you want to also use an index:

for i, (x, y, z) in mySeq:
  ...

The example with zip would now allow more meaningful names:

for (length, height) in zip(seqA, seqB):
  let area = length * height

---

Parentheses must be used to make a clear, understandable difference between for i, val in mySeq and for (x, y) in mySeq, where i is an index, val is a whole tuple, and x and y are elements of that tuple.

This would allow to have a cleaner, nicer and more readable code.

Thoughts?

[dom96]

Sounds good to me.

👍

@narimiran about

for val in mySeq:
  let
    x = val[0]
    y = val[1]
    z = val[2]
  ...

It's not the best, but it can be a little bit easier:

let mySeq = @[(1, 2, 3), (3, 4, 5), (3, 1, 2)]
for val in mySeq:
  let (x, y, z) = val

[krux02]

Well I think a full pattern matching library should be the goal. And the library should be so flexible, that it works in cases like these with arbitrary complexity.

[narimiran]

a full pattern matching library should be the goal

Agreed. Or even better yet - not a library, but a standard Nim feature.

But until that happens, tuple unpacking as proposed would be a nice thing to have.

[andreaferretti]

Something similar exists in the form of https://github.com/numforge/loop-fusion

[narimiran]

@andreaferretti Correct me if I'm wrong, but to me it looks like Loop Fusion solves the problem of zip unpacking, but it cannot be used for unpacking of seq[tuple] (cc @mratsim)

-1 from me. You can write:

for a, b, c in items(mySeq):
   ...

[krux02]

@NotTito the problem is that it doesn't work when you also want the index.

@NotTito but it doesn't work without calling items or when you need the index along the values

[andreaferretti]

@narimiran You are right, I mentioned it because I think the same approach could be extended to tuples

Ok you guys are are right.

[narimiran]

Now I've seen @dom96 had similar idea back in 2015: #2436

This received quite an amount of thumb-ups — can we have this before v1.0?

[dom96]

This isn't necessary for v1.0

[mratsim]

Note that the difference between iterators that return tuples and seq of tuples must be documented.

In the first case, iterators like pairs don't need parenthesis today:

iterator myPair[T](x: seq[T]): (int, T) =

  for i in 0 ..< x.len:
    yield (i, x[i])  # Packed tuple


let pow2 = @[1, 2, 4, 8, 16, 32]

for j, val in pow2.myPair(): # magically unpacked
  echo "2^", j, " = ", val