Zipping iterators

[lukaszcz]

We should have iterators for2, map2, etc., which are equivalent to for, map, etc., on zipped lists / data structures.

For example,

for2 (acc := a) (x in lst1; y in lst2) {
  f acc x y
}

would be equivalent to

for (acc := a) (x, y in zip lst1 lst2) {
  f acc x y
}

The first is better both for readability / understandability for newcomers and efficiency (no intermediate list created).

[janmasrovira]

On a fresh reading of the proposed syntax I would think that y in lst2 is a nested loop rather than zipped.

[lukaszcz]

Would

for (acc := a) (x, y in lst1, lst2) {
  ...
}

be better?

But then maybe it's not so different from using zip.

[0xBiry]

Draft implementation for for2 and map2

Hi 👋,

Here’s a small draft implementation for for2 and map2 inspired by the discussion here.
The goal is to allow iteration over two collections in parallel without creating an intermediate zipped list, improving both performance and readability.

def map2 (f : a -> b -> c) (xs : List a) (ys : List b) : List c =
match (xs, ys) with
| ([], ) -> []
| (, []) -> []
| (x :: xt, y :: yt) -> f x y :: map2 f xt yt

def for2 (init : s) (xs : List a) (ys : List b) (f : s -> a -> b -> s) : s =
match (xs, ys) with
| ([], ) -> init
| (, []) -> init
| (x :: xt, y :: yt) -> for2 (f init x y) xt yt f

Example usage:

map2 (+) [1, 2, 3] [4, 5, 6] -- returns [5, 7, 9]

for2 0 [1, 2] [10, 20] (\acc x y -> acc + x * y) -- returns 50

This approach could be:

Generalized to work with other iterable types, not only lists.

Extended to for3, map3, etc. for multiple collections.

Optimized further at the compiler level to avoid function call overhead.

Happy to help refine or test this further 🚀