zip does not work when arguments are list and some other Iterator

[mzagozen]

Acton Version

0.24.1.20250129.19.42.50

Steps to Reproduce and Observed Behavior

The code compiles, but does not enter the for loop and print out expected:

def _test_zip():
    left = "1"
    right = "2"
    sides = [left, right]
    z = zip(sides, reversed(sides))
    # z = zip(sides, list(reversed(sides)))
    for a, b in z:
        print(a, b)

If we instead "materialize" the elements from the Iterator with list() it works!

Expected Behavior

Should print out

1 2
2 1

[plajjan]

@sydow isn't this your domain? Going via a list() should not make a difference, I think. Why is it? Surely there must be some simple fix here, right? :) Like it looks like all the protocols etc are lined up for this to work, yet it doesn't...

[sydow]

I spent quite some time today to look at this. I immediately found an easy (and recent) bug, but the problem was not solved. It took me a long time to find the other problem, which I hope @nordlander can fix easily.

The first problem is that zip was not adapted to the change in iterators. Here is zip_next in builtin_functions.c:

 $WORD B_IteratorD_zip_next(B_IteratorD_zip it) {
      $WORD w1 = it->it1->$class->__next__(it->it1);
      $WORD w2 = it->it2->$class->__next__(it->it2);
      if (w1 && w2)
          return $NEWTUPLE(2,w1,w2);
    else
         return NULL;
}

Obviously this is from the time when iterations were NULL-terminated and was missed in the conversion. The if-statement must be replaced by just

return $NEWTUPLE(2,w1,w2);

The second problem was more difficult to find. But look at the example; zip is applied to two arguments, a list (sides) and an iterator (reverse(sides)). Both these are of types that implement Iterable. Here is the generated C code (partial):

#include "rts/common.h"
#include "out/types/ziptest.h"
B_NoneType ziptestQ__test_zip () {
    B_Iterable W_16 = (B_Iterable)B_IterableD_IteratorG_witness;
    B_Iterable W_17 = (B_Iterable)B_SequenceD_listG_witness->W_Collection;
    B_Sequence W_20 = (B_Sequence)B_SequenceD_listG_witness;
    B_str left = to$str("1");
    B_str right = to$str("2");
    B_list sides = B_mk_list(2, left , right);
    B_Iterator z = ((B_Iterator (*) (B_Iterable, B_Iterable, B_list, B_Iterator))B_zip)(W_16, W_17, sides, ((B_Iterator (*) (B_Sequence, B_list))B_reversed)(W_20, sides));
    return B_None;
}

Note that W_16 is the witness that Iterators implement Iterable and W_17 the witness that lists implement Iterable. So the order of these two parameters seems to have been mixed up; it seems obvious that the 1st and 3rd parameters belong together and the 2nd and 4th. But then it is difficult to understand that this error hasn't showed up much earlier? (Note that the outcommented example works since the two witnesses are the same).

I hope Johan can easily see where some list of parameters is not reversed when it should have been (or conversely).

I should add that the problem is introduced early, already during type-checking, but that is not surprising.