superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,243 @@
+# === List iteration ===
+result = []
+for x in [1, 2, 3]:
+    result.append(x)
+assert result == [1, 2, 3], 'iterate over list'
+
+# list with mixed types
+result = []
+for x in [1, 'a', True]:
+    result.append(x)
+assert result == [1, 'a', True], 'iterate over mixed list'
+
+# empty list
+result = []
+for x in []:
+    result.append(x)
+assert result == [], 'iterate over empty list'
+
+# nested list items
+result = []
+for x in [[1, 2], [3, 4]]:
+    result.append(x)
+assert result == [[1, 2], [3, 4]], 'iterate over nested lists'
+
+# === Tuple iteration ===
+result = []
+for x in (1, 2, 3):
+    result.append(x)
+assert result == [1, 2, 3], 'iterate over tuple'
+
+# empty tuple
+result = []
+for x in ():
+    result.append(x)
+assert result == [], 'iterate over empty tuple'
+
+# tuple with mixed types
+result = []
+for x in (1, 'b', False):
+    result.append(x)
+assert result == [1, 'b', False], 'iterate over mixed tuple'
+
+# === Dict iteration (yields keys) ===
+result = []
+for k in {'a': 1, 'b': 2, 'c': 3}:
+    result.append(k)
+assert result == ['a', 'b', 'c'], 'iterate over dict yields keys'
+
+# empty dict
+result = []
+for k in {}:
+    result.append(k)
+assert result == [], 'iterate over empty dict'
+
+# dict preserves insertion order
+result = []
+d = {'z': 1, 'a': 2, 'm': 3}
+for k in d:
+    result.append(k)
+assert result == ['z', 'a', 'm'], 'dict iteration preserves insertion order'
+
+# === String iteration (yields chars) ===
+result = []
+for c in 'abc':
+    result.append(c)
+assert result == ['a', 'b', 'c'], 'iterate over string yields chars'
+
+# empty string
+result = []
+for c in '':
+    result.append(c)
+assert result == [], 'iterate over empty string'
+
+# string with punctuation
+result = []
+for c in 'hi!':
+    result.append(c)
+assert result == ['h', 'i', '!'], 'iterate over string with punctuation'
+
+# string with unicode (multi-byte UTF-8 characters)
+result = []
+for c in 'héllo':
+    result.append(c)
+assert result == ['h', 'é', 'l', 'l', 'o'], 'iterate over string with accented char'
+
+# string with CJK characters
+result = []
+for c in '日本':
+    result.append(c)
+assert result == ['日', '本'], 'iterate over string with CJK chars'
+
+# string with emoji
+result = []
+for c in 'a🎉b':
+    result.append(c)
+assert result == ['a', '🎉', 'b'], 'iterate over string with emoji'
+
+# heap string
+s = 'xyz'
+s = s + '!'  # Force heap allocation
+result = []
+for c in s:
+    result.append(c)
+assert result == ['x', 'y', 'z', '!'], 'iterate over heap string'
+
+# === Bytes iteration (yields ints) ===
+result = []
+for b in b'abc':
+    result.append(b)
+assert result == [97, 98, 99], 'iterate over bytes yields ints'
+
+# empty bytes
+result = []
+for b in b'':
+    result.append(b)
+assert result == [], 'iterate over empty bytes'
+
+# bytes with various values
+result = []
+for b in b'\x00\x01\xff':
+    result.append(b)
+assert result == [0, 1, 255], 'iterate over bytes with special values'
+
+# === Range iteration (existing functionality) ===
+result = []
+for i in range(3):
+    result.append(i)
+assert result == [0, 1, 2], 'iterate over range'
+
+# range with step
+result = []
+for i in range(0, 6, 2):
+    result.append(i)
+assert result == [0, 2, 4], 'iterate over range with step'
+
+# === Nested iteration ===
+result = []
+for outer in [[1, 2], [3, 4]]:
+    for inner in outer:
+        result.append(inner)
+assert result == [1, 2, 3, 4], 'nested for loops'
+
+# iterate over string within list
+result = []
+for s in ['ab', 'cd']:
+    for c in s:
+        result.append(c)
+assert result == ['a', 'b', 'c', 'd'], 'nested string iteration'
+
+# === Using loop variable after loop ===
+for x in [1, 2, 3]:
+    pass
+assert x == 3, 'loop variable persists after loop'
+
+for y in 'abc':
+    pass
+assert y == 'c', 'string loop variable persists'
+
+# === List mutation during iteration ===
+# Python allows list mutation during iteration (unlike dict).
+# The iterator checks current length on each iteration.
+
+# appending during iteration - new items are seen
+result = []
+lst = [1, 2, 3]
+for x in lst:
+    result.append(x)
+    if x == 2:
+        lst.append(4)
+assert result == [1, 2, 3, 4], 'appending to list during iteration sees new items'
+assert lst == [1, 2, 3, 4], 'list was modified'
+
+# appending multiple items
+result = []
+lst = [1]
+for x in lst:
+    result.append(x)
+    if x < 5:
+        lst.append(x + 1)
+assert result == [1, 2, 3, 4, 5], 'can grow list dynamically during iteration'
+
+# === Modifying via copy pattern ===
+original = [1, 2, 3]
+copy = list(original)
+for x in copy:
+    if x == 2:
+        original.append(4)
+assert original == [1, 2, 3, 4], 'modifying list via copy pattern'
+
+# === Sum pattern ===
+total = 0
+for n in [1, 2, 3, 4, 5]:
+    total = total + n
+assert total == 15, 'sum pattern with list'
+
+# === Early break simulation via flag ===
+# (break not implemented, using flag pattern)
+found = False
+for x in [1, 2, 3, 4, 5]:
+    if not found and x == 3:
+        found = True
+assert found == True, 'find pattern with flag'
+
+# === Accumulator patterns ===
+# count items
+count = 0
+for _ in ['a', 'b', 'c']:
+    count = count + 1
+assert count == 3, 'count items'
+
+# concatenate strings
+result = ''
+for s in ['a', 'b', 'c']:
+    result = result + s
+assert result == 'abc', 'concatenate strings'
+
+# === Dict key-value access pattern ===
+d = {'x': 10, 'y': 20}
+total = 0
+for k in d:
+    total = total + d[k]
+assert total == 30, 'dict key-value access in loop'
+
+# === Dict mutation during iteration ===
+# Python allows modifying existing key values during iteration (no size change).
+# It also allows pop + add that keeps size the same (iterator sees new keys).
+
+# modifying existing values is allowed
+d = {'a': 1, 'b': 2, 'c': 3}
+for k in d:
+    d[k] = d[k] * 10
+assert d == {'a': 10, 'b': 20, 'c': 30}, 'modify dict values during iteration'
+
+# pop + add keeping same size is allowed, iterator sees new keys
+d = {'a': 1, 'b': 2, 'c': 3}
+result = []
+for k in d:
+    result.append(k)
+    if k == 'a':
+        d.pop('b')
+        d['x'] = 4  # size unchanged
+assert result == ['a', 'c', 'x'], 'dict pop+add same size sees new keys'
+assert d == {'a': 1, 'c': 3, 'x': 4}, 'dict was modified correctly'

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

@@ -0,0 +1,66 @@
+# === Basic for loop ===
+result = []
+for i in range(5):
+    result.append(i)
+assert result == [0, 1, 2, 3, 4], 'basic for loop'
+
+# === Tuple unpacking in for loop ===
+pairs = [(1, 2), (3, 4), (5, 6)]
+sums = []
+for a, b in pairs:
+    sums.append(a + b)
+assert sums == [3, 7, 11], 'for loop with pair unpacking'
+
+# === Triple unpacking ===
+triples = [(1, 2, 3), (4, 5, 6)]
+products = []
+for a, b, c in triples:
+    products.append(a * b * c)
+assert products == [6, 120], 'for loop with triple unpacking'
+
+# === Nested tuple unpacking ===
+nested = [((1, 2), 3), ((4, 5), 6)]
+results = []
+for (a, b), c in nested:
+    results.append(a + b + c)
+assert results == [6, 15], 'for loop with nested unpacking'
+
+# === Deep nested unpacking ===
+deep = [((1, 2), (3, 4)), ((5, 6), (7, 8))]
+sums = []
+for (a, b), (c, d) in deep:
+    sums.append(a + b + c + d)
+assert sums == [10, 26], 'for loop with deep nested unpacking'
+
+# === Mixed depth unpacking ===
+mixed = [(1, (2, 3)), (4, (5, 6))]
+results = []
+for a, (b, c) in mixed:
+    results.append(a + b + c)
+assert results == [6, 15], 'for loop with mixed depth unpacking'
+
+# === Unpacking with else clause ===
+pairs = [(1, 2), (3, 4)]
+total = 0
+for a, b in pairs:
+    total += a + b
+else:
+    total += 100
+assert total == 110, 'for loop unpacking with else clause'
+
+# === Enumerate with unpacking ===
+items = ['a', 'b', 'c']
+result = []
+for i, val in enumerate(items):
+    result.append((i, val))
+assert result == [(0, 'a'), (1, 'b'), (2, 'c')], 'enumerate with unpacking'
+
+# === Dict items unpacking ===
+d = {'x': 1, 'y': 2}
+keys = []
+vals = []
+for k, v in d.items():
+    keys.append(k)
+    vals.append(v)
+assert sorted(keys) == ['x', 'y'], 'dict items unpacking keys'
+assert sorted(vals) == [1, 2], 'dict items unpacking values'

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

@@ -0,0 +1,20 @@
+# === Basic generator expression ===
+result = list(x * 2 for x in range(5))
+assert result == [0, 2, 4, 6, 8], 'basic generator expression'
+
+# === With condition ===
+result = list(x for x in range(10) if x % 2 == 0)
+assert result == [0, 2, 4, 6, 8], 'generator with condition'
+
+# === Nested generators ===
+result = list(x + y for x in range(3) for y in range(2))
+assert result == [0, 1, 1, 2, 2, 3], 'nested generator'
+
+# === Generator in function call ===
+result = sum(x for x in range(5))
+assert result == 10, 'generator in sum()'
+
+# === Generator with unpacking ===
+pairs = [(1, 2), (3, 4)]
+result = list(a + b for a, b in pairs)
+assert result == [3, 7], 'generator with unpacking'

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

@@ -0,0 +1,7 @@
+# xfail=cpython
+# TODO: When proper generators are implemented, this test should be removed.
+# Currently generator expressions return lists in Monty, not generator objects.
+# This test verifies the temporary behavior until generators are properly implemented.
+gen_result = (x * 2 for x in range(5))
+assert type(gen_result) == list, 'generator expr currently returns list'
+assert gen_result == [0, 2, 4, 6, 8], 'generator expr value'

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

@@ -0,0 +1,3 @@
+for x in 42:
+    pass
+# Raise=TypeError("'int' object is not iterable")

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

@@ -0,0 +1,145 @@
+# === Basic lambda ===
+# no-arg lambda
+f = lambda: 42
+assert f() == 42, 'no-arg lambda'
+
+# single arg lambda
+f = lambda x: x + 1
+assert f(5) == 6, 'single arg lambda'
+
+# === Multiple arguments ===
+f = lambda x, y: x + y
+assert f(2, 3) == 5, 'multi-arg lambda'
+
+f = lambda x, y, z: x * y + z
+assert f(2, 3, 4) == 10, 'three-arg lambda'
+
+# === Default arguments ===
+f = lambda x, y=10: x + y
+assert f(5) == 15, 'lambda with default'
+assert f(5, 3) == 8, 'lambda override default'
+
+f = lambda x=1, y=2: x * y
+assert f() == 2, 'lambda all defaults'
+assert f(3) == 6, 'lambda override first default'
+assert f(3, 4) == 12, 'lambda override all defaults'
+
+# === Lambda as expression (immediate call) ===
+assert (lambda x: x * 2)(5) == 10, 'immediate call'
+assert (lambda: 'hello')() == 'hello', 'immediate call no args'
+assert (lambda x, y: x - y)(10, 3) == 7, 'immediate call multi args'
+
+# === Lambda in data structures ===
+funcs = [lambda x: x + 1, lambda x: x * 2, lambda x: x**2]
+assert funcs[0](3) == 4, 'lambda in list - add'
+assert funcs[1](3) == 6, 'lambda in list - mul'
+assert funcs[2](3) == 9, 'lambda in list - pow'
+
+# === Lambda assigned and called later ===
+square = lambda x: x * x
+double = lambda x: x + x
+assert square(4) == 16, 'lambda assigned square'
+assert double(4) == 8, 'lambda assigned double'
+
+# === Lambda with operations ===
+f = lambda x: x > 5
+assert f(6) is True, 'lambda comparison gt'
+assert f(4) is False, 'lambda comparison not gt'
+
+f = lambda x: x if x > 0 else -x
+assert f(5) == 5, 'lambda ternary positive'
+assert f(-5) == 5, 'lambda ternary negative'
+
+
+# === Closures ===
+def make_adder(n):
+    return lambda x: x + n
+
+
+add5 = make_adder(5)
+add10 = make_adder(10)
+assert add5(3) == 8, 'closure capture add5'
+assert add10(3) == 13, 'closure capture add10'
+
+
+def make_multiplier(factor):
+    return lambda x: x * factor
+
+
+times3 = make_multiplier(3)
+assert times3(4) == 12, 'closure capture multiplier'
+
+# === Nested lambdas ===
+f = lambda x: lambda y: x + y
+add_to_5 = f(5)
+assert add_to_5(3) == 8, 'nested lambda'
+
+f = lambda x: lambda y: lambda z: x + y + z
+assert f(1)(2)(3) == 6, 'triple nested lambda'
+
+# === Lambda in list comprehension ===
+squared = [f(x) for x in [1, 2, 3, 4] for f in [lambda n: n * n]]
+# Note: this tests lambda in comprehension context, though due to late binding
+# all items use the same lambda
+
+# === Lambda returns another lambda ===
+compose = lambda f: lambda g: lambda x: f(g(x))
+inc = lambda x: x + 1
+double = lambda x: x * 2
+inc_then_double = compose(double)(inc)
+assert inc_then_double(3) == 8, 'lambda composition'  # double(inc(3)) = double(4) = 8
+
+# === Lambda repr ===
+f = lambda: None
+r = repr(f)
+assert '<lambda>' in r, 'lambda repr contains <lambda>'
+assert 'function' in r, 'lambda repr contains function'
+
+# === Lambda with *args ===
+f = lambda *args: sum(args)
+assert f() == 0, 'lambda varargs empty'
+assert f(1) == 1, 'lambda varargs one'
+assert f(1, 2, 3) == 6, 'lambda varargs multiple'
+
+# === Lambda with keyword arguments ===
+f = lambda x, *, y: x + y
+assert f(1, y=2) == 3, 'lambda keyword only'
+
+f = lambda **kwargs: len(kwargs)
+assert f() == 0, 'lambda kwargs empty'
+assert f(a=1, b=2) == 2, 'lambda kwargs multiple'
+
+# === Mixed parameters ===
+f = lambda a, b=2, *args, c, d=4, **kwargs: (a, b, args, c, d, len(kwargs))
+result = f(1, 2, 3, 4, c=10, d=20, e=30, f=40)
+assert result == (1, 2, (3, 4), 10, 20, 2), 'lambda mixed params'
+
+# === Unpacking in immediate lambda calls ===
+xs = [1, 2, 3]
+assert (lambda *a: a)(*xs) == (1, 2, 3), 'lambda with *args unpacking'
+assert (lambda **k: k)(**{'a': 1}) == {'a': 1}, 'lambda with **kwargs unpacking'
+assert (lambda *a, **k: (a, k))(1, 2, x=3) == ((1, 2), {'x': 3}), 'lambda mixed unpack'
+
+# === Lambda parameter shadowing ===
+# Inner lambda shadows outer variable - outer should not capture it
+
+
+def make_shadowing_lambda():
+    x = 10
+    # inner lambda has param x, so outer lambda should NOT capture x from make_shadowing_lambda
+    return lambda: (lambda x: x + 1)
+
+
+outer_fn = make_shadowing_lambda()
+inner_fn = outer_fn()
+assert inner_fn(5) == 6, 'inner lambda takes x as param'
+
+
+def test_inner_lambda_capture():
+    y = 5
+    # outer lambda binds y as param, inner lambda captures from outer lambda, not test_inner_lambda_capture
+    g = lambda y: (lambda: y)
+    return g(7)()
+
+
+assert test_inner_lambda_capture() == 7, 'inner lambda captures outer lambda param'

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

@@ -0,0 +1,7 @@
+# Regression test: list.extend() with a non-iterable should still raise TypeError
+# with the correct message. This verifies that the list_extend opcode helper in
+# collections.rs (for [*expr] literals) and the list.extend() method in
+# types/list.rs are separate code paths that do not interfere with each other.
+a = []
+a.extend(1)
+# Raise=TypeError("'int' object is not iterable")

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

@@ -0,0 +1,3 @@
+a = [1, 2, 3]
+a[10]
+# Raise=IndexError('list index out of range')

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

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

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

@@ -0,0 +1,10 @@
+# Test that list.index with start > end doesn't panic but raises ValueError
+[1, 2, 3].index(1, 5, 2)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "list__index_start_gt_end.py", line 2, in <module>
+    [1, 2, 3].index(1, 5, 2)
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+ValueError: list.index(x): x not in list
+"""