superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/test_cases/list__ops.py

@@ -0,0 +1,473 @@
+# === List concatenation (+) ===
+assert [1, 2] + [3, 4] == [1, 2, 3, 4], 'basic concat'
+assert [] + [1, 2] == [1, 2], 'empty left concat'
+assert [1, 2] + [] == [1, 2], 'empty right concat'
+assert [] + [] == [], 'empty both concat'
+assert [1] + [2] + [3] + [4] == [1, 2, 3, 4], 'multiple concat'
+assert [[1]] + [[2]] == [[1], [2]], 'nested concat'
+
+# === Augmented assignment (+=) ===
+lst = [1, 2]
+lst += [3, 4]
+assert lst == [1, 2, 3, 4], 'basic iadd'
+
+lst = [1]
+alias = lst
+lst += [2]
+assert lst is alias, 'list += preserves identity'
+assert alias == [1, 2], 'list += mutates through aliases'
+
+lst = [1, 2, 3]
+index = 1
+lst[index] += 5
+assert lst == [1, 7, 3], 'subscript += updates the selected list item'
+
+try:
+    lst = [1]
+    lst[5] += 1
+    assert False, 'subscript += past the end of a list should raise IndexError'
+except IndexError as e:
+    assert e.args == ('list index out of range',), 'subscript += list index error matches normal setitem'
+
+lst = [1]
+lst += []
+assert lst == [1], 'iadd empty'
+
+lst = [1]
+lst += [2]
+lst += [3]
+assert lst == [1, 2, 3], 'multiple iadd'
+
+lst = [1, 2]
+lst += lst
+assert lst == [1, 2, 1, 2], 'iadd self'
+
+# === List length ===
+assert len([]) == 0, 'len empty'
+assert len([1, 2, 3]) == 3, 'len basic'
+
+lst = [1]
+lst.append(2)
+assert len(lst) == 2, 'len after append'
+
+# === List indexing ===
+a = []
+a.append('value')
+assert a[0] == 'value', 'getitem basic'
+
+a = [1, 2, 3]
+assert a[0 - 1] == 3, 'getitem negative index'
+assert a[-1] == 3, 'getitem -1'
+assert a[-2] == 2, 'getitem -2'
+
+# === List repr/str ===
+assert repr([]) == '[]', 'empty list repr'
+assert str([]) == '[]', 'empty list str'
+
+assert repr([1, 2, 3]) == '[1, 2, 3]', 'list repr'
+assert str([1, 2, 3]) == '[1, 2, 3]', 'list str'
+
+# === List repetition (*) ===
+assert [1, 2] * 3 == [1, 2, 1, 2, 1, 2], 'list mult int'
+assert 3 * [1, 2] == [1, 2, 1, 2, 1, 2], 'int mult list'
+assert [1] * 0 == [], 'list mult zero'
+assert [1] * -1 == [], 'list mult negative'
+assert [] * 5 == [], 'empty list mult'
+assert [1, 2] * 1 == [1, 2], 'list mult one'
+assert [[1]] * 2 == [[1], [1]], 'nested list mult'
+
+# === List repetition augmented assignment (*=) ===
+lst = [1, 2]
+lst *= 2
+assert lst == [1, 2, 1, 2], 'list imult'
+
+lst = [1]
+lst *= 0
+assert lst == [], 'list imult zero'
+
+# === list() constructor ===
+assert list() == [], 'list() empty'
+assert list([1, 2, 3]) == [1, 2, 3], 'list from list'
+assert list((1, 2, 3)) == [1, 2, 3], 'list from tuple'
+assert list(range(3)) == [0, 1, 2], 'list from range'
+assert list('abc') == ['a', 'b', 'c'], 'list from string'
+assert list(b'abc') == [97, 98, 99], 'list from bytes'
+assert list({'a': 1, 'b': 2}) == ['a', 'b'], 'list from dict yields keys'
+
+# non-ASCII strings (multi-byte UTF-8)
+assert list('héllo') == ['h', 'é', 'l', 'l', 'o'], 'list from string with accented char'
+assert list('日本') == ['日', '本'], 'list from string with CJK chars'
+assert list('a🎉b') == ['a', '🎉', 'b'], 'list from string with emoji'
+
+# === list.append() ===
+lst = []
+lst.append(1)
+assert lst == [1], 'append to empty'
+lst.append(2)
+assert lst == [1, 2], 'append to non-empty'
+lst.append(lst)  # append self creates cycle
+assert len(lst) == 3, 'append self increases length'
+
+# === list.insert() ===
+# Basic insert at various positions
+lst = [1, 2, 3]
+lst.insert(0, 'a')
+assert lst == ['a', 1, 2, 3], 'insert at beginning'
+
+lst = [1, 2, 3]
+lst.insert(1, 'a')
+assert lst == [1, 'a', 2, 3], 'insert in middle'
+
+lst = [1, 2, 3]
+lst.insert(3, 'a')
+assert lst == [1, 2, 3, 'a'], 'insert at end'
+
+# Insert beyond length appends
+lst = [1, 2, 3]
+lst.insert(100, 'a')
+assert lst == [1, 2, 3, 'a'], 'insert beyond length appends'
+
+# Insert with negative index
+lst = [1, 2, 3]
+lst.insert(-1, 'a')
+assert lst == [1, 2, 'a', 3], 'insert at -1 (before last)'
+
+lst = [1, 2, 3]
+lst.insert(-2, 'a')
+assert lst == [1, 'a', 2, 3], 'insert at -2'
+
+lst = [1, 2, 3]
+lst.insert(-100, 'a')
+assert lst == ['a', 1, 2, 3], 'insert very negative clamps to 0'
+
+# === list.pop() ===
+lst = [1, 2, 3]
+assert lst.pop() == 3, 'pop without argument returns last'
+assert lst == [1, 2], 'pop removes last element'
+
+lst = [1, 2, 3]
+assert lst.pop(0) == 1, 'pop(0) returns first'
+assert lst == [2, 3], 'pop(0) removes first element'
+
+lst = [1, 2, 3]
+assert lst.pop(1) == 2, 'pop(1) returns middle'
+assert lst == [1, 3], 'pop(1) removes middle element'
+
+lst = [1, 2, 3]
+assert lst.pop(-1) == 3, 'pop(-1) returns last'
+assert lst == [1, 2], 'pop(-1) removes last element'
+
+lst = [1, 2, 3]
+assert lst.pop(-2) == 2, 'pop(-2) returns second to last'
+assert lst == [1, 3], 'pop(-2) removes second to last element'
+
+# === list.remove() ===
+lst = [1, 2, 3, 2]
+lst.remove(2)
+assert lst == [1, 3, 2], 'remove removes first occurrence'
+
+lst = ['a', 'b', 'c']
+lst.remove('b')
+assert lst == ['a', 'c'], 'remove string element'
+
+# === list.clear() ===
+lst = [1, 2, 3]
+lst.clear()
+assert lst == [], 'clear empties the list'
+
+lst = []
+lst.clear()
+assert lst == [], 'clear on empty list is no-op'
+
+# === list.copy() ===
+lst = [1, 2, 3]
+copy = lst.copy()
+assert copy == [1, 2, 3], 'copy creates equal list'
+assert copy is not lst, 'copy creates new list object'
+lst.append(4)
+assert copy == [1, 2, 3], 'copy is independent'
+
+# === list.extend() ===
+lst = [1, 2]
+lst.extend([3, 4])
+assert lst == [1, 2, 3, 4], 'extend with list'
+
+lst = [1]
+lst.extend((2, 3))
+assert lst == [1, 2, 3], 'extend with tuple'
+
+lst = [1]
+lst.extend(range(2, 5))
+assert lst == [1, 2, 3, 4], 'extend with range'
+
+lst = [1]
+lst.extend('ab')
+assert lst == [1, 'a', 'b'], 'extend with string'
+
+lst = []
+lst.extend([])
+assert lst == [], 'extend empty with empty'
+
+# === list.index() ===
+lst = [1, 2, 3, 2]
+assert lst.index(2) == 1, 'index finds first occurrence'
+assert lst.index(3) == 2, 'index finds element'
+assert lst.index(2, 2) == 3, 'index with start'
+assert lst.index(2, 1, 4) == 1, 'index with start and end'
+
+# === list.count() ===
+lst = [1, 2, 2, 3, 2]
+assert lst.count(2) == 3, 'count multiple occurrences'
+assert lst.count(1) == 1, 'count single occurrence'
+assert lst.count(4) == 0, 'count zero occurrences'
+assert [].count(1) == 0, 'count on empty list'
+
+# === list.reverse() ===
+lst = [1, 2, 3]
+lst.reverse()
+assert lst == [3, 2, 1], 'reverse modifies in place'
+
+lst = [1]
+lst.reverse()
+assert lst == [1], 'reverse single element'
+
+lst = []
+lst.reverse()
+assert lst == [], 'reverse empty list'
+
+# === list.sort() ===
+lst = [3, 1, 2]
+lst.sort()
+assert lst == [1, 2, 3], 'sort integers'
+
+lst = ['b', 'c', 'a']
+lst.sort()
+assert lst == ['a', 'b', 'c'], 'sort strings'
+
+lst = [3, 1, 2]
+lst.sort(reverse=True)
+assert lst == [3, 2, 1], 'sort with reverse=True'
+
+lst = []
+lst.sort()
+assert lst == [], 'sort empty list'
+
+lst = [1]
+lst.sort()
+assert lst == [1], 'sort single element'
+
+# === list.sort(key=...) ===
+lst = ['banana', 'apple', 'cherry']
+lst.sort(key=len)
+assert lst == ['apple', 'banana', 'cherry'], 'sort by len'
+
+lst = [[1, 2, 3], [4], [5, 6]]
+lst.sort(key=len)
+assert lst == [[4], [5, 6], [1, 2, 3]], 'sort nested lists by len'
+
+lst = [[1, 2, 3], [4], [5, 6]]
+lst.sort(key=len, reverse=True)
+assert lst == [[1, 2, 3], [5, 6], [4]], 'sort by len reverse'
+
+lst = [-3, 1, -2, 4]
+lst.sort(key=abs)
+assert lst == [1, -2, -3, 4], 'sort by abs'
+
+# key=None is same as no key
+lst = [3, 1, 2]
+lst.sort(key=None)
+assert lst == [1, 2, 3], 'sort with key=None'
+
+lst = [3, 1, 2]
+lst.sort(key=None, reverse=True)
+assert lst == [3, 2, 1], 'sort with key=None reverse'
+
+# Empty list with key
+lst = []
+lst.sort(key=len)
+assert lst == [], 'sort empty list with key'
+
+# key=int for string-to-int conversion
+lst = ['-3', '1', '-2', '4']
+lst.sort(key=int)
+assert lst == ['-3', '-2', '1', '4'], 'sort strings by int value'
+
+lst = ['10', '2', '1', '100']
+lst.sort(key=int)
+assert lst == ['1', '2', '10', '100'], 'sort numeric strings by int value'
+
+lst = ['10', '2', '1', '100']
+lst.sort(key=int, reverse=True)
+assert lst == ['100', '10', '2', '1'], 'sort numeric strings by int reverse'
+
+# user-defined key function
+
+
+def last_char(s):
+    return s[-1]
+
+
+lst = ['cherry', 'banana', 'apple']
+lst.sort(key=last_char)
+assert lst == ['banana', 'apple', 'cherry'], 'sort by last char'
+
+
+# key function might raise exception
+lst = ['']
+try:
+    lst.sort(key=last_char)
+except IndexError:
+    pass  # expected since last_char('') raises IndexError
+
+
+# === List assignment (setitem) ===
+# Basic assignment
+lst = [1, 2, 3]
+lst[0] = 10
+assert lst == [10, 2, 3], 'setitem at index 0'
+
+lst = [1, 2, 3]
+lst[1] = 20
+assert lst == [1, 20, 3], 'setitem at index 1'
+
+lst = [1, 2, 3]
+lst[2] = 30
+assert lst == [1, 2, 30], 'setitem at last index'
+
+# Negative index assignment
+lst = [1, 2, 3]
+lst[-1] = 100
+assert lst == [1, 2, 100], 'setitem at -1'
+
+lst = [1, 2, 3]
+lst[-2] = 200
+assert lst == [1, 200, 3], 'setitem at -2'
+
+lst = [1, 2, 3]
+lst[-3] = 300
+assert lst == [300, 2, 3], 'setitem at -3'
+
+# Assigning different types
+lst = [1, 2, 3]
+lst[0] = 'hello'
+assert lst == ['hello', 2, 3], 'setitem string value'
+
+lst = [1, 2, 3]
+lst[1] = [4, 5]
+assert lst == [1, [4, 5], 3], 'setitem list value'
+
+lst = [1, 2, 3]
+lst[0] = None
+assert lst == [None, 2, 3], 'setitem None value'
+
+# Multiple assignments
+lst = [0, 0, 0]
+lst[0] = 1
+lst[1] = 2
+lst[2] = 3
+assert lst == [1, 2, 3], 'multiple setitem'
+
+# Assignment preserves other elements
+lst = ['a', 'b', 'c', 'd']
+lst[1] = 'B'
+assert lst[0] == 'a', 'setitem preserves element 0'
+assert lst[1] == 'B', 'setitem changes element 1'
+assert lst[2] == 'c', 'setitem preserves element 2'
+assert lst[3] == 'd', 'setitem preserves element 3'
+
+# === Bool indices ===
+# Python allows True/False as indices (True=1, False=0)
+lst = ['a', 'b', 'c']
+assert lst[False] == 'a', 'getitem with False'
+assert lst[True] == 'b', 'getitem with True'
+
+lst = ['x', 'y', 'z']
+lst[False] = 'X'
+assert lst == ['X', 'y', 'z'], 'setitem with False'
+
+lst = ['x', 'y', 'z']
+lst[True] = 'Y'
+assert lst == ['x', 'Y', 'z'], 'setitem with True'
+
+# === Nested list equality ===
+# same-length lists with matching nested elements
+assert [[1, 2], [3, 4]] == [[1, 2], [3, 4]], 'nested list eq'
+# same-length but different nested elements (exercises py_eq early return)
+assert [[1, 2], [3, 4]] != [[1, 2], [3, 5]], 'nested list ne same length'
+assert [[]] != [[1]], 'nested empty vs non-empty'
+# deeper nesting
+assert [[[1]]] == [[[1]]], 'deep nested list eq'
+assert [[[1]]] != [[[2]]], 'deep nested list ne'
+# mixed nesting depths
+assert [[1], 2] == [[1], 2], 'mixed nesting eq'
+assert [[1], 2] != [[1], 3], 'mixed nesting ne'
+
+# === Nested list repr ===
+assert repr([[1, 2], [3, 4]]) == '[[1, 2], [3, 4]]', 'nested list repr'
+assert repr([[]]) == '[[]]', 'list containing empty list repr'
+assert repr([[1], [2, 3]]) == '[[1], [2, 3]]', 'nested varied len repr'
+
+# === list.remove() with nested elements ===
+x = [1, 2]
+lst = [x, [3, 4], x]
+lst.remove([1, 2])
+assert lst == [[3, 4], [1, 2]], 'remove nested list element'
+
+lst = [1, [2, 3], 4]
+lst.remove([2, 3])
+assert lst == [1, 4], 'remove nested from mixed'
+
+# === list.index() with nested elements ===
+lst = [[3], [1, 2], [4]]
+assert lst.index([1, 2]) == 1, 'index with nested list'
+
+lst = [[1], [2], [1]]
+assert lst.index([1]) == 0, 'index nested finds first'
+
+# === list.count() with nested elements ===
+lst = [[1, 2], [3], [1, 2], 4, [1, 2]]
+assert lst.count([1, 2]) == 3, 'count nested list elements'
+assert lst.count([3]) == 1, 'count single nested occurrence'
+assert lst.count([99]) == 0, 'count nested not found'
+assert [].count([1]) == 0, 'count on empty list'
+
+# === Nested list containment ===
+assert [1, 2] in [[1, 2], [3, 4]], 'nested list in'
+assert [5, 6] not in [[1, 2], [3, 4]], 'nested list not in'
+assert [] in [[], [1]], 'empty list in list of lists'
+
+# === List unpacking (PEP 448) ===
+a = [1, 2]
+b = [3, 4]
+assert [*a] == [1, 2], 'single list unpack'
+assert [*a, *b] == [1, 2, 3, 4], 'double list unpack'
+assert [0, *a, 5] == [0, 1, 2, 5], 'mixed list unpack'
+assert [*[]] == [], 'unpack empty list'
+assert [*(1, 2)] == [1, 2], 'unpack tuple into list'
+assert [*'abc'] == ['a', 'b', 'c'], 'unpack string into list'
+assert [*{'x': 1, 'y': 2}] == ['x', 'y'], 'unpack dict keys into list'
+# Heap-allocated set: covers the HeapData::Set arm in list_extend
+assert sorted([*{1, 2, 3}]) == [1, 2, 3], 'unpack set into list'
+# Heap-allocated Str (result of concat, not interned): covers HeapData::Str in list_extend
+hs = 'hel' + 'lo'
+assert [*hs] == ['h', 'e', 'l', 'l', 'o'], 'unpack heap string into list'
+
+
+# Non-iterable heap-allocated Ref (closure) hits the inner `_` arm in list_extend.
+# A plain top-level function is Value::DefFunction (not a Ref), so a closure is
+# required to reach the Value::Ref(_) branch (HeapData that is not List/Tuple/Set/Dict/Str).
+def _make_list_unpack_closure():
+    _sentinel = 1
+
+    def _inner():
+        return _sentinel
+
+    return _inner
+
+
+_list_unpack_closure = _make_list_unpack_closure()
+try:
+    _x = [*_list_unpack_closure]
+    assert False, 'expected TypeError for non-iterable heap closure in list unpack'
+except TypeError:
+    pass

package/ref-monty/crates/monty/test_cases/list__pop_empty.py

@@ -0,0 +1,9 @@
+[].pop()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__pop_empty.py", line 1, in <module>
+    [].pop()
+    ~~~~~~~~
+IndexError: pop from empty list
+"""

package/ref-monty/crates/monty/test_cases/list__pop_out_of_range.py

@@ -0,0 +1,9 @@
+[1, 2, 3].pop(10)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__pop_out_of_range.py", line 1, in <module>
+    [1, 2, 3].pop(10)
+    ~~~~~~~~~~~~~~~~~
+IndexError: pop index out of range
+"""

package/ref-monty/crates/monty/test_cases/list__pop_type_error.py

@@ -0,0 +1,9 @@
+[].pop('not an int')
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__pop_type_error.py", line 1, in <module>
+    [].pop('not an int')
+    ~~~~~~~~~~~~~~~~~~~~
+TypeError: 'str' object cannot be interpreted as an integer
+"""

package/ref-monty/crates/monty/test_cases/list__remove_not_found.py

@@ -0,0 +1,9 @@
+[1, 2, 3].remove(4)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__remove_not_found.py", line 1, in <module>
+    [1, 2, 3].remove(4)
+    ~~~~~~~~~~~~~~~~~~~
+ValueError: list.remove(x): x not in list
+"""

package/ref-monty/crates/monty/test_cases/list__setitem_dict_index.py

@@ -0,0 +1,13 @@
+# Test using a dict as a list setitem index (should raise TypeError)
+# This covers the code path where a non-LongInt Ref type is used as an index
+lst = [1, 2, 3]
+d = {'key': 'value'}
+lst[d] = 42
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__setitem_dict_index.py", line 5, in <module>
+    lst[d] = 42
+    ~~~~~~
+TypeError: list indices must be integers or slices, not dict
+"""

package/ref-monty/crates/monty/test_cases/list__setitem_huge_int_index.py

@@ -0,0 +1,13 @@
+# Test using a huge LongInt as a list setitem index (should raise IndexError)
+# This covers the code path where a LongInt exceeds i64 range
+lst = [1, 2, 3]
+huge = 2**100
+lst[huge] = 42
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__setitem_huge_int_index.py", line 5, in <module>
+    lst[huge] = 42
+    ~~~~~~~~~
+IndexError: cannot fit 'int' into an index-sized integer
+"""

package/ref-monty/crates/monty/test_cases/list__setitem_index_error.py

@@ -0,0 +1,10 @@
+lst = [1, 2, 3]
+lst[10] = 'value'
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__setitem_index_error.py", line 2, in <module>
+    lst[10] = 'value'
+    ~~~~~~~
+IndexError: list assignment index out of range
+"""

package/ref-monty/crates/monty/test_cases/list__setitem_type_error.py

@@ -0,0 +1,10 @@
+lst = [1, 2, 3]
+lst['key'] = 'value'
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__setitem_type_error.py", line 2, in <module>
+    lst['key'] = 'value'
+    ~~~~~~~~~~
+TypeError: list indices must be integers or slices, not str
+"""

package/ref-monty/crates/monty/test_cases/list__unpack_type_error.py

@@ -0,0 +1,2 @@
+[*42]
+# Raise=TypeError('Value after * must be an iterable, not int')

package/ref-monty/crates/monty/test_cases/longint__index_error.py

@@ -0,0 +1,3 @@
+big = 10**100
+[1, 2, 3][big]
+# Raise=IndexError("cannot fit 'int' into an index-sized integer")

package/ref-monty/crates/monty/test_cases/longint__repeat_error.py

@@ -0,0 +1,3 @@
+big = 10**100
+'abc' * big
+# Raise=OverflowError("cannot fit 'int' into an index-sized integer")

package/ref-monty/crates/monty/test_cases/loop__break_continue.py

@@ -0,0 +1,113 @@
+# === Basic break ===
+result = []
+for x in [1, 2, 3, 4, 5]:
+    if x == 3:
+        break
+    result.append(x)
+assert result == [1, 2], 'break exits loop early'
+
+# === Break skips else ===
+flag = 0
+for x in [1, 2, 3]:
+    if x == 2:
+        break
+else:
+    flag = 1
+assert flag == 0, 'break skips else clause'
+
+# === No break runs else ===
+flag = 0
+for x in [1, 2, 3]:
+    pass
+else:
+    flag = 1
+assert flag == 1, 'completing loop runs else clause'
+
+# === Basic continue ===
+result = []
+for x in [1, 2, 3, 4, 5]:
+    if x % 2 == 0:
+        continue
+    result.append(x)
+assert result == [1, 3, 5], 'continue skips iteration'
+
+# === Continue with else ===
+flag = 0
+for x in [1, 2, 3]:
+    if x == 2:
+        continue
+else:
+    flag = 1
+assert flag == 1, 'continue does not skip else clause'
+
+# === Nested loops - break inner ===
+result = []
+for i in [1, 2, 3]:
+    for j in ['a', 'b', 'c']:
+        if j == 'b':
+            break
+        result.append((i, j))
+assert result == [(1, 'a'), (2, 'a'), (3, 'a')], 'break only affects inner loop'
+
+# === Nested loops - continue inner ===
+result = []
+for i in [1, 2]:
+    for j in ['a', 'b', 'c']:
+        if j == 'b':
+            continue
+        result.append((i, j))
+assert result == [(1, 'a'), (1, 'c'), (2, 'a'), (2, 'c')], 'continue only affects inner loop'
+
+# === Break in nested with else on inner ===
+result = []
+for i in [1, 2]:
+    for j in [10, 20, 30]:
+        if j == 20:
+            break
+        result.append(j)
+    else:
+        result.append('inner-else')
+assert result == [10, 10], 'break skips inner else'
+
+# === No break in inner runs inner else ===
+result = []
+for i in [1, 2]:
+    for j in [10, 20]:
+        result.append(j)
+    else:
+        result.append('inner-else')
+assert result == [10, 20, 'inner-else', 10, 20, 'inner-else'], 'no break runs inner else'
+
+# === Continue does not affect else ===
+result = []
+for x in [1, 2, 3]:
+    if x == 2:
+        continue
+    result.append(x)
+else:
+    result.append('else')
+assert result == [1, 3, 'else'], 'continue does not prevent else'
+
+# === Empty loop with else ===
+flag = 0
+for x in []:
+    flag = 1
+else:
+    flag = 2
+assert flag == 2, 'empty loop runs else'
+
+# === Break on first iteration ===
+result = []
+for x in [1, 2, 3]:
+    result.append('before')
+    break
+    result.append('after')  # unreachable
+assert result == ['before'], 'break on first iteration'
+
+# === Continue on every iteration ===
+result = []
+for x in [1, 2, 3]:
+    result.append(x)
+    continue
+    result.append('after')  # unreachable
+assert result == [1, 2, 3], 'continue on every iteration'