I think you both are missing the point. This is not hardcoded, this is how you avoid extra computations. You don't have to calculate the rotation of A each time. Computing an alphabet is pretty common in cryptography. For rot13, the alphabet is known upfront so you can skip its computation.

No it's O(n)

Another issue, your solution wrongly translates [+..,,].
It outputs:

if (*p) do {
  *p += 1;
  putchar(*p);
  *p = getchar();
} while (*p);

Whereas the expected result is:

if (*p) do {
  *p += 1;
  putchar(*p);
  putchar(*p);
  *p = getchar();
  *p = getchar();
} while (*p);

I think there an issue with the expected solution.
+[] should translate to:

*p += 1;
if (*p) do {
} while (*p);

The infinite loop is intended!

all interpreters on cw are overranked

Then you should really try To BrainFuck Transpiler.
This one is really hard and is rated 4 kyu (why?!)

What about this test?

Test.assertDeepEquals( List.replicate(0,undefined).toList(), List.empty.toList() );

If undefined is an acceptable value, then this test is wrong.

I'm passing all tests, except one. What's the expected result of:

• List.iterate(inc, 0).last()
• List.iterate(inc, 0).foldr(identity)
• List.repeat(3).reverse().head()

Should we throw? Return undefined / empty list ?
The intended behavior for infinite list is not well described...

The amount of work required by this kata is huge. You should consider trimming the method list.

Doing it in 354 lines.

Thank you so much for this kata! It was so hard but quite enjoyable!