superacli 1.1.6 → 1.1.8

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

@@ -1,473 +0,0 @@
-# === 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

@@ -1,9 +0,0 @@
-[].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

@@ -1,9 +0,0 @@
-[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

@@ -1,9 +0,0 @@
-[].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

@@ -1,9 +0,0 @@
-[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

@@ -1,13 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,113 +0,0 @@
-# === 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'