Problem with using tuple.at inside of bool.while

[c71n93]

The puzzles #2818 and #2819 describe the problems with bool.while. Trying to figure out what's wrong with the test from puzzle #2818, I got a strange result. I tried to simplify the test and took an already existing working test.

This test from bool-test.eo is passing successfully:

[] > last-while-dataization-object
  memory 0 > x
  eq. > @
    while.
      x.as-int.lt 2
      [i]
        seq > @
          *
            x.write (x.as-int.plus 1)
            x.as-int
    3

This modified test fails with error:

[] > last-while-dataization-object-modified
  * 1 2 3 4 > arr
  memory 0 > x
  eq. > @
    while.
      x.as-int.lt 2
      [i]
        seq > @
          *
            arr.at
              x.as-int
            x.write (x.as-int.plus 1)
            x.as-int
    3

The only thing I added here is iterating over a tuple before incrementing x (arr.at (x.as-int)). It turns out that in this case there is one extra iteration. I have not been able to figure out what exactly the problem is here.

[c71n93]

@maxonfjvipon WDYT? Do you have any ideas?

[maxonfjvipon]

@c71n93 I think you need to try to repeat such behavior in test written on Java. Then it'll be possible to debug it

[c71n93]

@maxonfjvipon I implemented this broken test on Java (#2839), but behaviour was different (test on Java didn't fail). Then I discovered that the problem is seq.

This two tests work differently:

[] > seq-single-dataization-int-equal-to-test
  memory 0 > x
  eq. > @
    seq
      *
        x.write 0
        x.write (x.as-int.plus 1)
        x.as-int
    1

[] > seq-single-dataization-int-equal-to-test-bug
  memory 0 > x
  eq. > @
    seq
      *
        at.
          * 0 1
          x.as-int
        x.write (x.as-int.plus 1)
        x.as-int
    1

In the second test seq dataizes as 0 instead of the expected 1. I implemented this test on Java (#2840) and suddenly it didn't fail too.

I couldn't figure out what the reason might be. Obviously, code generated from eo tests and tests written manually on Java are different. As I could understand from the debugger, all elements of the seq are dataized in both cases.

@maxonfjvipon Do you have any ideas?

[maxonfjvipon]

@c71n93 I wrote the same tests in java and first test returned 1, the second returned 0:

@Test
void test() {
    Phi counter = new EOmemory(Phi.Φ);
    counter.attr(0).put(new Data.ToPhi(0L));

    Phi arr = new PhWith(
        new PhWith(
            new EOtuple$EOempty(Phi.Φ).attr("with").get().copy(),
            0, new Data.ToPhi(0L)
        ).attr("with").get().copy(),
        0, new Data.ToPhi(1L)
    );

    Phi first = new PhWith(new PhCopy(new PhMethod(counter, "write")), 0, new Data.ToPhi(0L));

    Phi second = new PhWith(
        new PhCopy(new PhMethod(arr, "at")),
        0, new PhMethod(counter, "as-int")
    );

    Phi args = new PhWith(
        new PhCopy(
            new PhMethod(
                new PhWith(
                    new PhCopy(
                        new PhMethod(
                            new PhWith(
                                new PhCopy(new PhMethod(new EOtuple$EOempty(Phi.Φ), "with")),
                                0,
                                first
                            ),
                            "with"
                        )
                    ),
                    0,
                    new PhWith(
                        new PhCopy(new PhMethod(counter, "write")),
                        0,
                        new PhWith(
                            new PhCopy(new PhMethod(new PhMethod(counter, "as-int"), "plus")),
                            0, new Data.ToPhi(1L)
                        )
                    )
                ),
                "with"
            )
        ),
        0, new PhMethod(counter, "as-int")
    );

    System.out.println(
        new Dataized(
            new PhWith(new EOseq(Phi.Φ), 0, args)
        ).take(Long.class)
    );
}

first and second are variables that indicates both cases, they're almost the same. You can try to play with it

[maxonfjvipon]

@c71n93 And yes, there's something wrong, but it's not related to seq.
There is one interesting line in PhDefault.

It caches the attribute that was got though decorator (φ or λ). If we're removing the caching - both tests become returning 1.

And I think the MAIN problem here is mutability of memory. How we can afford caching if memory is mutable and cache does not know about changes of the memory internal value?

[maxonfjvipon]

@c71n93 still an issue?

[c71n93]

@maxonfjvipon it was resolved