rapydscript-ns 0.9.4 → 0.9.5

package/src/monaco-language-service/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/src/output/classes.pyj

@@ -125,8 +125,8 @@ def print_class(output):
             output.indent()
             output.spaced('if', '(this.ρσ_object_id', '===', 'undefined)', 'Object.defineProperty(this,', '"ρσ_object_id",', '{"value":++ρσ_object_counter})')
             output.end_statement()
-            if self.has_attr_dunders:
-                # Wrap in a Proxy so __getattr__/__setattr__/__delattr__/__getattribute__ are triggered.
+            if self.has_attr_dunders or self.slots:
+                # Wrap in a Proxy so __getattr__/__setattr__/__delattr__/__getattribute__/__slots__ are triggered.
                 output.indent()
                 output.print('var ρσ_proxy = ρσ_JS_Proxy ? new ρσ_JS_Proxy(this, ρσ_attr_proxy_handler) : this')
                 output.end_statement()
@@ -330,6 +330,29 @@ def print_class(output):
     output.print('.prototype, "__class__", {get: function() { return this.constructor; }, configurable: true})')
     output.end_statement()
 
+    # __slots__ enforcement: emit allowed attribute set on prototype
+    if self.slots:
+        output.indent()
+        self.name.print(output)
+        # Merge parent slots (if any) with this class's slots + bound methods
+        slot_obj = '{'
+        for i in range(self.slots.length):
+            if i > 0:
+                slot_obj += ', '
+            slot_obj += JSON.stringify(self.slots[i]) + ': true'
+        for i in range(self.bound.length):
+            if self.slots.length or i > 0:
+                slot_obj += ', '
+            slot_obj += JSON.stringify(self.bound[i]) + ': true'
+        slot_obj += '}'
+        if self.parent:
+            output.print('.prototype.__ρσ_slots__ = Object.assign({}, ')
+            self.parent.print(output)
+            output.print('.prototype.__ρσ_slots__, ' + slot_obj + ')')
+        else:
+            output.print('.prototype.__ρσ_slots__ = Object.assign({}, ' + slot_obj + ')')
+        output.end_statement()
+
     # Other statements in the class context (including nested class definitions).
     # Emitted BEFORE __init_subclass__ so that the hook can see class variables.
     # This matches Python's behaviour: the class body executes first, then the

package/src/parse.pyj

@@ -1622,6 +1622,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if parent_details and parent_details.has_attr_dunders:
                 definition.has_attr_dunders = True
                 class_details.has_attr_dunders = True
+        # Detect __slots__ = [...] in class body
+        for stmt in definition.body:
+            assign = stmt
+            if is_node_type(stmt, AST_SimpleStatement):
+                assign = stmt.body
+            if is_node_type(assign, AST_Assign) and is_node_type(assign.left, AST_SymbolRef) and assign.left.name is '__slots__':
+                if is_node_type(assign.right, AST_Array):
+                    slot_names = []
+                    for elem in assign.right.elements:
+                        if is_node_type(elem, AST_String):
+                            slot_names.push(elem.value)
+                    definition.slots = slot_names
+                    class_details.slots = slot_names
+                break
         # find the class variables
         class_var_names = {}
         # Ensure that if a class variable refers to another class variable in

package/test/chainmap.pyj

@@ -170,7 +170,7 @@ ok(not (ChainMap({'a': 1}) == {'a': 1, 'b': 2}))
 # ── 11. repr ──────────────────────────────────────────────────────────────────
 
 # RapydScript's repr() quotes strings with double quotes (as Counter/OrderedDict do)
-ae(ChainMap({'a': 1}, {'b': 2}).__repr__(), 'ChainMap({"a": 1}, {"b": 2})')
+ae(ChainMap({'a': 1}, {'b': 2}).__repr__(), "ChainMap({'a': 1}, {'b': 2})")
 
 # ── 12. dynamic — changes to underlying maps are visible ──────────────────────
 

package/test/dataclasses.pyj

@@ -76,7 +76,7 @@ class _Hidden:
     secret: str = field('s3cr3t', repr=False)
 
 h = _Hidden("visible")
-ae(repr(h), '_Hidden(public="visible")')
+ae(repr(h), "_Hidden(public='visible')")
 ae(h.secret, 's3cr3t')
 
 # ── 6. field() init=False ─────────────────────────────────────────────────────
@@ -209,11 +209,10 @@ ae(ch2.y, 0)
 ae(ch2.z, 'default')
 
 # repr shows all fields including inherited
-# (RapydScript repr() uses double quotes for strings, like JavaScript)
 r = repr(ch2)
 ok('x=10' in r)
 ok('y=0' in r)
-ok('z="default"' in r)
+ok("z='default'" in r)
 
 # ── 15. MISSING sentinel ──────────────────────────────────────────────────────
 
@@ -240,7 +239,7 @@ class _Explicit:
 
 ex = _Explicit()
 ae(ex.name, 'x')
-ae(repr(ex), '_Explicit(name="x")')
+ae(repr(ex), "_Explicit(name='x')")
 
 # ── 18. Nested list field with asdict ────────────────────────────────────────
 

package/test/enum.pyj

@@ -94,7 +94,7 @@ ae(_Direction.NORTH.name,  'NORTH')
 ae(_Direction.NORTH.value, 'north')
 ae(_Direction.SOUTH.value, 'south')
 # RapydScript repr() wraps strings in double quotes (JS convention)
-ae(repr(_Direction.NORTH), '<_Direction.NORTH: "north">')
+ae(repr(_Direction.NORTH), "<_Direction.NORTH: 'north'>")
 ae(str(_Direction.EAST),   '_Direction.EAST')
 ae(len(list(_Direction)), 4)
 

package/test/pprint.pyj

@@ -25,8 +25,8 @@ ae(pformat(True), 'True')
 ae(pformat(False), 'False')
 ae(pformat(42), '42')
 ae(pformat(3.14), '3.14')
-ae(pformat('hello'), '"hello"')
-ae(pformat(''), '""')
+ae(pformat('hello'), "'hello'")
+ae(pformat(''), "''")
 
 # ── 2. Empty containers ─────────────────────────────────────────────────────
 
@@ -38,7 +38,7 @@ ae(pformat(frozenset()), 'frozenset()')
 # ── 3. Short containers fit on a single line ────────────────────────────────
 
 ae(pformat([1, 2, 3]), '[1, 2, 3]')
-ae(pformat({'a': 1, 'b': 2}), '{"a": 1, "b": 2}')
+ae(pformat({'a': 1, 'b': 2}), "{'a': 1, 'b': 2}")
 ae(pformat({1, 2, 3}), '{1, 2, 3}')
 ae(pformat(frozenset([1, 2, 3])), 'frozenset({1, 2, 3})')
 
@@ -50,7 +50,7 @@ ae(_wide, '[1,\n 2,\n 3,\n 4,\n 5]')
 # ── 5. Wide dict breaks across lines, keys sorted by default ────────────────
 
 _wd = pformat({'name': 'Alice', 'age': 30}, width=15)
-ae(_wd, '{"age": 30,\n "name": "Alice"}')
+ae(_wd, "{'age': 30,\n 'name': 'Alice'}")
 
 # ── 6. sort_dicts=False preserves insertion order ───────────────────────────
 
@@ -59,8 +59,8 @@ _d = dict()
 _d.set('c', 1)
 _d.set('a', 2)
 _d.set('b', 3)
-ae(pformat(_d, sort_dicts=False), '{"c": 1, "a": 2, "b": 3}')
-ae(pformat(_d, sort_dicts=True),  '{"a": 2, "b": 3, "c": 1}')
+ae(pformat(_d, sort_dicts=False), "{'c': 1, 'a': 2, 'b': 3}")
+ae(pformat(_d, sort_dicts=True),  "{'a': 2, 'b': 3, 'c': 1}")
 
 # ── 7. pp() defaults sort_dicts=False, has same parameters as pprint ────────
 
@@ -71,7 +71,7 @@ pp({'c': 1, 'a': 2})
 
 ae(pformat([1, [2, [3, [4]]]], depth=1), '[1, [...]]')
 ae(pformat([1, [2, [3, [4]]]], depth=2), '[1, [2, [...]]]')
-ae(pformat({'a': {'b': {'c': 1}}}, depth=1), '{"a": {...}}')
+ae(pformat({'a': {'b': {'c': 1}}}, depth=1), "{'a': {...}}")
 
 # ── 9. Nested containers — multi-line indentation ───────────────────────────
 
@@ -96,8 +96,8 @@ ade(_c.split('\n'), ['[1, 2, 3, 4, 5,', ' 6, 7, 8]'])
 # ── 12. saferepr — single-line repr; recursive marker for cycles ────────────
 
 ae(saferepr([1, 2, 3]), '[1, 2, 3]')
-ae(saferepr({'a': 1}), '{"a": 1}')
-ae(saferepr('text'), '"text"')
+ae(saferepr({'a': 1}), "{'a': 1}")
+ae(saferepr('text'), "'text'")
 
 # Self-referential list -> recursive marker, not infinite recursion
 _self_list = [1, 2]
@@ -175,7 +175,7 @@ _data = {
 
 # Width permits inline lists.
 ae(pformat(_data, width=120),
-   '{"count": 2, "users": [{"age": 30, "name": "Alice"}, {"age": 25, "name": "Bob"}]}')
+   "{'count': 2, 'users': [{'age': 30, 'name': 'Alice'}, {'age': 25, 'name': 'Bob'}]}")
 
 # Narrow width forces multi-line expansion.
 _narrow = pformat(_data, width=30)
@@ -202,12 +202,12 @@ ae(_col.getvalue(), '[1, 2, 3]\n')
 
 _col2 = _Collector()
 pprint({'a': 1}, stream=_col2)
-ae(_col2.getvalue(), '{"a": 1}\n')
+ae(_col2.getvalue(), "{'a': 1}\n")
 
 # ── 21. Empty / single-element containers do not break ──────────────────────
 
 ae(pformat([42]), '[42]')
-ae(pformat({'k': 'v'}), '{"k": "v"}')
+ae(pformat({'k': 'v'}), "{'k': 'v'}")
 ae(pformat([], width=1), '[]')
 ae(pformat({}, width=1), '{}')
 
@@ -217,8 +217,8 @@ ae(pformat([True, False, None, 0]), '[True, False, None, 0]')
 
 # ── 23. Strings with special characters get repr-escaped ────────────────────
 
-ae(pformat('a\nb'), '"a\\nb"')
-ae(pformat('"quoted"'), '"\\"quoted\\""')
+ae(pformat('a\nb'), "'a\\nb'")
+ae(pformat('"quoted"'), '\'"quoted"\'')
 
 # ── 24. underscore_numbers parameter is accepted (currently ignored) ────────
 
@@ -229,4 +229,4 @@ ae(pformat(1000000, underscore_numbers=True), '1000000')
 _col3 = _Collector()
 pp({'b': 2, 'a': 1}, stream=_col3, width=80)
 # pp defaults sort_dicts=False, so 'b' comes before 'a' (insertion order)
-ae(_col3.getvalue(), '{"b": 2, "a": 1}\n')
+ae(_col3.getvalue(), "{'b': 2, 'a': 1}\n")

package/test/python_features.pyj

@@ -523,7 +523,7 @@ def _test_raise_from_none():
 _test_raise_from_none()
 
 # ── 23. __slots__ ────────────────────────────────────────────────────────────
-# STATUS: ✗ NOT ENFORCED — __slots__ is accepted but does not restrict attrs.
+# STATUS: ✓ WORKS — __slots__ enforced via Proxy; raises AttributeError for undeclared attrs.
 
 # ── 24. Nested classes ───────────────────────────────────────────────────────
 # STATUS: ✓ WORKS — added in commit 44c9802; tested fully in test/classes.pyj

package/test/str.pyj

@@ -196,11 +196,11 @@ for f in (str, repr):
     ae(f(False), 'False')
     ae(f(None), 'None')
     ae(f(1), '1')
-    ae(f([1,'2']), '[1, "2"]')
-    ae(f({1:[1, '2']}), '{"1":[1, "2"]}')
-    ae(f({1:'a', 2:'b'}), '{"1":"a", "2":"b"}')
+    ae(f([1,'2']), "[1, '2']")
+    ae(f({1:[1, '2']}), "{'1': [1, '2']}")
+    ae(f({1:'a', 2:'b'}), "{'1': 'a', '2': 'b'}")
 ae(str('a'), 'a')
-ae(repr('a'), '"a"')
+ae(repr('a'), "'a'")
 
 bytes = list(range(256))
 assrt.deepEqual(bytes, list(encodings.base64decode(encodings.base64encode(bytes))))

package/test/unit/index.js

@@ -2996,6 +2996,96 @@ assrt.equal(fib(15), 610)
         js_checks: ["ρσ_op_add(", "ρσ_op_sub(", "ρσ_op_or(", "ρσ_op_and("],
     },
 
+    {
+        name: "operator_dict_or",
+        description: "| on plain objects creates a new merged dict; numeric | still works",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "a = {'x': 1, 'y': 2}",
+            "b = {'z': 3}",
+            "c = a | b",
+            "assrt.deepEqual(c, {'x': 1, 'y': 2, 'z': 3})",
+            "assrt.notStrictEqual(c, a)",
+            "assrt.equal(5 | 3, 7)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_dict_ior",
+        description: "|= on plain objects merges in-place",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "d = {'a': 1}",
+            "ref = d",
+            "d |= {'b': 2}",
+            "assrt.deepEqual(d, {'a': 1, 'b': 2})",
+            "assrt.strictEqual(d, ref)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_dict_or_override",
+        description: "| on plain objects: right-hand values override left on key collision",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "a = {'x': 1, 'y': 2}",
+            "b = {'y': 99, 'z': 3}",
+            "c = a | b",
+            "assrt.equal(c['y'], 99)",
+            "assrt.equal(c['x'], 1)",
+            "assrt.equal(c['z'], 3)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_type_error_bitwise",
+        description: "bitwise operators raise TypeError for invalid types",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "def check(fn, msg):",
+            "    try:",
+            "        fn()",
+            "        assrt.ok(False, 'expected TypeError for ' + msg)",
+            "    except TypeError:",
+            "        assrt.ok(True)",
+            'check(def(): "str" & 5;, "str & int")',
+            'check(def(): None | 5;, "None | int")',
+            'check(def(): "a" ^ 1;, "str ^ int")',
+            'check(def(): "a" << 1;, "str << int")',
+            'check(def(): "a" >> 1;, "str >> int")',
+            "assrt.equal(7 & 3, 3)",
+            "assrt.equal(1 | 2, 3)",
+            "assrt.equal(5 ^ 3, 6)",
+            "assrt.equal(1 << 3, 8)",
+            "assrt.equal(8 >> 2, 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_type_error_unary",
+        description: "unary operators raise TypeError for invalid types",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "def check(fn, msg):",
+            "    try:",
+            "        fn()",
+            "        assrt.ok(False, 'expected TypeError for ' + msg)",
+            "    except TypeError:",
+            "        assrt.ok(True)",
+            'check(def(): -"hello";, "neg str")',
+            'check(def(): +None;, "pos None")',
+            'check(def(): ~"world";, "invert str")',
+            "assrt.equal(-5, -5)",
+            "assrt.equal(+3, 3)",
+            "assrt.equal(~0, -1)",
+        ].join("\n"),
+    },
+
     // ── nested comprehensions ──────────────────────────────────────────────
 
     {
@@ -5373,6 +5463,291 @@ assrt.equal(fib(15), 610)
         ].join("\n"),
     },
 
+    // ── Exception.args ───────────────────────────────────────────────────────
+    {
+        name: "exception_args_single",
+        description: "Exception with single arg populates .args and .message",
+        src: [
+            "# globals: assrt",
+            "e = Exception('hello')",
+            "assrt.deepEqual(e.args, ['hello'])",
+            "assrt.equal(e.message, 'hello')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_multiple",
+        description: "Exception with multiple args populates .args tuple",
+        src: [
+            "# globals: assrt",
+            "e = Exception('err', 42, 'extra')",
+            "assrt.deepEqual(e.args, ['err', 42, 'extra'])",
+            "assrt.equal(e.message, 'err')",
+            "assrt.equal(e.args[1], 42)",
+            "assrt.equal(e.args[2], 'extra')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_empty",
+        description: "Exception with no args has empty .args and empty .message",
+        src: [
+            "# globals: assrt",
+            "e = Exception()",
+            "assrt.deepEqual(e.args, [])",
+            "assrt.equal(e.message, '')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_subclass",
+        description: "Exception subclass inherits .args behavior",
+        src: [
+            "# globals: assrt",
+            "e = ValueError('bad', 'value')",
+            "assrt.deepEqual(e.args, ['bad', 'value'])",
+            "assrt.equal(e.message, 'bad')",
+            "assrt.ok(isinstance(e, ValueError))",
+            "assrt.ok(isinstance(e, Exception))",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_catch",
+        description: "Caught exception preserves .args",
+        src: [
+            "# globals: assrt",
+            "try:",
+            "    raise ValueError('oops', 123)",
+            "except ValueError as e:",
+            "    assrt.deepEqual(e.args, ['oops', 123])",
+            "    assrt.equal(e.message, 'oops')",
+            "    assrt.equal(e.args[1], 123)",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_len",
+        description: "len() works on exception .args",
+        src: [
+            "# globals: assrt",
+            "e = Exception('a', 'b', 'c')",
+            "assrt.equal(len(e.args), 3)",
+            "e2 = Exception()",
+            "assrt.equal(len(e2.args), 0)",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_exception_group",
+        description: "ExceptionGroup .args contains message and exceptions list",
+        src: [
+            "# globals: assrt",
+            "eg = ExceptionGroup('grp', [ValueError('v')])",
+            "assrt.equal(eg.args[0], 'grp')",
+            "assrt.equal(len(eg.args), 2)",
+            "assrt.equal(eg.message, 'grp')",
+            "assrt.ok(isinstance(eg.args[1][0], ValueError))",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_custom_class",
+        description: "Custom exception class with __init__ can use .args",
+        src: [
+            "# globals: assrt",
+            "class MyError(Exception):",
+            "    def __init__(self, code, detail):",
+            "        Exception.__init__(self, code, detail)",
+            "        self.code = code",
+            "        self.detail = detail",
+            "e = MyError(404, 'not found')",
+            "assrt.deepEqual(e.args, [404, 'not found'])",
+            "assrt.equal(e.code, 404)",
+            "assrt.equal(e.detail, 'not found')",
+            "assrt.equal(e.message, 404)",
+        ].join("\n"),
+    },
+
+    // ── __slots__ ─────────────────────────────────────────────────────────────
+    {
+        name: "slots_basic",
+        description: "__slots__ allows declared attributes",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    __slots__ = ['x', 'y']",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(1, 2)",
+            "assrt.equal(p.x, 1)",
+            "assrt.equal(p.y, 2)",
+            "p.x = 10",
+            "assrt.equal(p.x, 10)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_raises_attributeerror",
+        description: "__slots__ raises AttributeError for undeclared attrs",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    __slots__ = ['x', 'y']",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(1, 2)",
+            "try:",
+            "    p.z = 3",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError as e:",
+            "    assrt.ok(str(e).indexOf('z') != -1)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_inherited",
+        description: "Subclass with __slots__ merges parent slots",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        self.x = 1",
+            "class Child(Base):",
+            "    __slots__ = ['y']",
+            "    def __init__(self):",
+            "        Base.__init__(self)",
+            "        self.y = 2",
+            "c = Child()",
+            "assrt.equal(c.x, 1)",
+            "assrt.equal(c.y, 2)",
+            "try:",
+            "    c.z = 3",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError:",
+            "    assrt.ok(True)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_subclass_no_slots",
+        description: "Subclass without __slots__ is unrestricted",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        self.x = 1",
+            "class Child(Base):",
+            "    def __init__(self):",
+            "        Base.__init__(self)",
+            "        self.y = 2",
+            "c = Child()",
+            "assrt.equal(c.x, 1)",
+            "assrt.equal(c.y, 2)",
+            "c.z = 3",
+            "assrt.equal(c.z, 3)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_empty",
+        description: "__slots__ = [] allows no instance attributes",
+        src: [
+            "# globals: assrt",
+            "class Empty:",
+            "    __slots__ = []",
+            "    pass",
+            "e = Empty()",
+            "try:",
+            "    e.x = 1",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError:",
+            "    assrt.ok(True)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_with_attr_dunders",
+        description: "__setattr__ takes priority over __slots__",
+        src: [
+            "# globals: assrt",
+            "class Tracked:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        object.__setattr__(self, 'log', [])",
+            "        self.x = 1",
+            "    def __setattr__(self, name, value):",
+            "        self.log.append(name)",
+            "        object.__setattr__(self, name, value)",
+            "t = Tracked()",
+            "assrt.equal(t.x, 1)",
+            "assrt.ok(t.log.length > 0)",
+        ].join("\n"),
+    },
+
+    // ── Container pretty-printing ─────────────────────────────────────────────
+
+    {
+        name: "repr_list_pretty",
+        description: "repr/str of lists uses repr on elements (quotes strings, shows None/True)",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr([1, 'hello', None, True]), \"[1, 'hello', None, True]\")",
+            "assrt.equal(str([1, 'hello', None, True]), \"[1, 'hello', None, True]\")",
+            "assrt.equal(repr([]), '[]')",
+            "assrt.equal(str([]), '[]')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_dict_pretty",
+        description: "repr/str of dicts uses single-quoted keys and values",
+        src: [
+            "# globals: assrt",
+            "d = dict()",
+            "d.set('key', 'val')",
+            "assrt.equal(repr(d), \"{'key': 'val'}\")",
+            "assrt.equal(str(d), \"{'key': 'val'}\")",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_set_pretty",
+        description: "repr/str of sets uses repr on elements",
+        src: [
+            "# globals: assrt",
+            "s = {1, 'two'}",
+            "r = repr(s)",
+            "assrt.ok(r.indexOf(\"'two'\") >= 0, 'set repr should quote strings')",
+            "assrt.ok(r.indexOf('1') >= 0, 'set repr should include numbers')",
+            "assrt.ok(r[0] is '{' and r[r.length-1] is '}', 'set repr uses braces')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_nested_containers",
+        description: "repr handles nested containers correctly",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr([[1], [2, 3]]), '[[1], [2, 3]]')",
+            "assrt.equal(repr([None, True, False]), '[None, True, False]')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_string_single_quotes",
+        description: "repr of strings uses Python-style single quotes",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr('hello'), \"'hello'\")",
+            "assrt.equal(repr(''), \"''\")",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_frozenset_pretty",
+        description: "repr/str of frozenset uses repr on elements",
+        src: [
+            "# globals: assrt",
+            "fs = frozenset([1, 'x'])",
+            "r = repr(fs)",
+            "assrt.ok(r.indexOf('frozenset(') is 0, 'starts with frozenset(')",
+            "assrt.ok(r.indexOf(\"'x'\") >= 0, 'frozenset repr should quote strings')",
+        ].join("\n"),
+    },
+
 ];
 
 // ── Runner ───────────────────────────────────────────────────────────────────