rapydscript-ns 0.9.4 → 0.9.5

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+version 0.9.5
+=======================
+* Added support for `__slots__` enforcement via JS Proxy (subclass merging, graceful fallback)
+* Added support for exception `.args` property (all exception classes capture constructor arguments)
+* Added support for dict `|` (merge) and `|=` (update) operators
+* Added Python-style `repr()` formatting: single-quoted strings, `repr()` applied to container elements
+* Added `interface extends` support in the language service TypeScript definition parser
+* Fix: Improved type checking for bitwise and unary operators (raises `TypeError` for invalid types)
+
 version 0.9.4
 =======================
 * Added the `statistics` standard library module (`mean`, `fmean`, `median`, `median_low`, `median_high`, `median_grouped`, `mode`, `multimode`, `stdev`, `pstdev`, `variance`, `pvariance`, `harmonic_mean`, `geometric_mean`, `quantiles`, `covariance`, `correlation`, `linear_regression`, `NormalDist`)

package/PYTHON_GAPS.md

@@ -77,17 +77,7 @@ when interoperating with JS APIs that return plain objects.
 
 ---
 
-### 1.5 `Exception.args` vs `.message`
-
-**Python:** `Exception('msg').args == ('msg',)` and `.message` is not a standard attribute.
-**RapydScript:** `.message` is the primary attribute (JS `Error` convention). `.args` is
-not populated as a tuple with the message.
-
-**Impact:** Code accessing `.args[0]` to get the error message will get `undefined`.
-
----
-
-### 1.6 Multiple Inheritance MRO
+### 1.5 Multiple Inheritance MRO
 
 **Python:** C3 linearization guarantees a deterministic and consistent method resolution order.
 **RapydScript:** Built on the JS prototype chain. In diamond inheritance or complex hierarchies
@@ -100,18 +90,7 @@ name. Hard to debug because no error is raised.
 
 ## 2. Missing Language Features
 
-### 2.1 `__slots__` Not Enforced
-
-`__slots__ = ['x', 'y']` is parsed and accepted but has no runtime effect — arbitrary
-attributes can still be set on instances. No `AttributeError` is raised for assignments to
-undeclared attributes.
-
-**Browser relevance:** Used frequently for memory efficiency and API documentation. Enforcement
-via `Object.seal()` or a `Proxy`-based guard would be possible in modern browsers.
-
----
-
-### 2.2 `__del__` Destructor — No Guaranteed Finalizer
+### 2.1 `__del__` Destructor — No Guaranteed Finalizer
 
 `__del__` methods are not called reliably. JavaScript's GC is non-deterministic and provides
 no equivalent to CPython's reference-counting finalizer.
@@ -124,7 +103,7 @@ that timing is not guaranteed.
 
 ---
 
-### 2.3 `locals()` Always Returns Empty Dict
+### 2.2 `locals()` Always Returns Empty Dict
 
 `vars()`, `locals()`, and `globals()` all exist as builtins. JavaScript provides no mechanism
 to introspect local variables at runtime, so `locals()` always returns an empty dict.
@@ -134,7 +113,7 @@ Python code that uses `locals()` for string template substitution
 
 ---
 
-### 2.4 `from module import *` Not Allowed
+### 2.3 `from module import *` Not Allowed
 
 Star imports are intentionally unsupported to prevent namespace pollution. Python developers
 who rely on them (e.g., `from math import *`) must enumerate imports explicitly.
@@ -143,7 +122,7 @@ who rely on them (e.g., `from math import *`) must enumerate imports explicitly.
 
 ---
 
-### 2.5 `asynccontextmanager` Not Available
+### 2.4 `asynccontextmanager` Not Available
 
 `contextlib.asynccontextmanager` is absent. Only synchronous `@contextmanager` is implemented.
 `async with` itself is also not supported — async context managers need `.acquire()`/`.release()`
@@ -151,7 +130,7 @@ calls instead.
 
 ---
 
-### 2.6 f-string Debugging Format `f'{x=}'` Not Supported
+### 2.5 f-string Debugging Format `f'{x=}'` Not Supported
 
 Python 3.8+ supports `f'{x=}'` which expands to `f'x={repr(x)}'`. This is not implemented.
 
@@ -162,7 +141,7 @@ print(f'{x=}')   # Python: "x=42". RapydScript: syntax error or wrong output
 
 ---
 
-### 2.7 Ellipsis Evaluates to `undefined`
+### 2.6 Ellipsis Evaluates to `undefined`
 
 `...` (Ellipsis) parses as a valid expression but evaluates to JS `undefined` rather than
 Python's `Ellipsis` singleton object. Code that stores `...` in containers or checks
@@ -342,7 +321,6 @@ Priority weighs frequency-of-need, effort-to-implement, and whether a workaround
 | Priority | Feature | Effort | Impact |
 |---|---|---|---|
 | High | `enum.IntEnum`, `IntFlag`, `Flag` | Medium | Protocol and permission modeling; bitfield enums |
-| Medium | `__slots__` enforcement via `Proxy` | Medium | Memory and API documentation |
 | Medium | `hashlib` shim over Web Crypto | Medium | Avoids verbatim Web Crypto calls in user code |
 | Medium | `fractions` module | Medium | Exact rational arithmetic |
 | Medium | f-string `f'{x=}'` debugging format | Low | Developer experience |

package/README.md

@@ -3312,16 +3312,26 @@ finally:
     cleanup()
 ```
 
+Like Python, exceptions accept variadic arguments stored in `.args`:
+
+```py
+e = ValueError('bad input', 42)
+print(e.args)       # ['bad input', 42]
+print(e.args[0])    # 'bad input'
+print(e.message)    # 'bad input' (first arg, for JS Error compatibility)
+```
+
 You can create your own Exception classes by inheriting from `Exception`, which
 is the JavaScript Error class, for more details on this, see the [MDN documentation](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Error).
 
 ```py
 class MyError(Exception):
-	def __init__(self, message):
-		self.name = 'MyError'
-		self.message = message
+	def __init__(self, code, detail):
+		Exception.__init__(self, code, detail)
+		self.code = code
+		self.detail = detail
 
-raise MyError('This is a custom error!')
+raise MyError(404, 'not found')
 ```
 
 You can catch multiple exception types in one `except` clause. Both the comma form and the tuple form are supported:
@@ -4013,6 +4023,7 @@ Python Feature Coverage
 | `super()` — 0-arg and 2-arg forms                                                                                                                                                                                                                             | `super().method()` and `super(Cls, self).method()` both work |
 | `except TypeA, TypeB as e:`                                                                                                                                                                                                                                   | RapydScript comma-separated form; catches multiple exception types |
 | `except (TypeA, TypeError) as e:`                                                                                                                                                                                                                             | Tuple form also supported |
+| `Exception.args` variadic constructor                                                                                                                                                                                                                          | `Exception('a', 'b').args == ['a', 'b']`; `.message` set to first arg for JS compatibility; works on all builtin and custom exception subclasses |
 | `except*` / `ExceptionGroup` (Python 3.11+)                                                                                                                                                                                                                   | Full support: `ExceptionGroup` class with `subgroup()`/`split()`; `except*` dispatches to typed handlers, re-raises unmatched; bare `except*:` catches all remaining |
 | `try / else`                                                                                                                                                                                                                                                  | `else` block runs only when no exception was raised |
 | `for / else`                                                                                                                                                                                                                                                  | `else` block runs when loop completes without `break`; nested break isolation works |
@@ -4158,7 +4169,6 @@ This restores the original RapydScript behavior: plain JS objects for `{}`, no o
 
 | Feature                               | Notes                                                                                   |
 |---------------------------------------|-----------------------------------------------------------------------------------------|
-| `__slots__` enforcement               | Accepted, but does not restrict attribute assignment                                    |
 | `locals()`                            | Returns an empty `dict`. JS has no runtime mechanism for introspecting local variables. |
 | `input(prompt)`                       | There is no simple cli input in browser; use `prompt()`                                 |
 | `compile()`                           | Python compile/code objects have no JS equivalent                                       |
@@ -4226,7 +4236,7 @@ Features that exist in RapydScript but behave differently from standard Python:
 | `//` floor division on floats | `math.floor(a/b)` always | uses `Math.floor` - same result for well-behaved floats                                                                                                                                                                    |
 | `%` on negative numbers | Result takes the sign of the divisor (`-7 % 3 == 2`) | Same as Python by default (via `python_modulo`, on by default). Disable with `from __python__ import no_python_modulo` to revert to raw JS remainder semantics.                                                              |
 | `global` / `nonlocal` scoping | Full cross-scope declaration | `global` works for module-level; if a variable exists in both an intermediate outer scope **and** the module-level scope, the outer scope takes precedence (differs from Python where `global` always forces module-level) |
-| `Exception.message` | Not standard; use `.args[0]` | `.message` is the standard attribute (JS `Error` style)                                                                                                                                                                    |
+| `Exception.message` | Not standard; use `.args[0]` | `.args` is populated (like Python); `.message` also set to first arg for JS `Error` compatibility                                                                                                                          |
 | Function call argument count | Too few args → `TypeError`; too many → `TypeError` | Too few args → extra params are `undefined`; too many → extras silently discarded. No `TypeError` is raised in either case.                                                                                                |
 | Positional-only param enforcement | Passing by keyword raises `TypeError` | Passing by keyword is silently ignored — the named arg is discarded and the parameter gets `undefined` (no error raised)                                                                                                   |
 | Keyword-only param enforcement | Passing positionally raises `TypeError` | Passing positionally raises no error — the extra positional arg is silently discarded and the default value is used                                                                                                        |

package/TODO.md

@@ -1,9 +1,9 @@
 
-
 - remove repl_mode and make repl make a new context for each "run" press
 
 - vscode plugin based on language service?
 
 
-I would like you to add support for [python 7n style literal] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Make sure it works in the web-repl. Update the README if it has any outdated info about this, and the PYTHON_FEATURE_COVERAGE report. Add a simple example to the bottom of the TODO document using this feature (make no other changes to that file). Remove the suggestion from PYTHON_GAPS if it is there.
+I would like you to add support for [python style __slots__ enforcement] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Make sure it works in the web-repl. Update the README if it has any outdated info about this, and the PYTHON_FEATURE_COVERAGE report. Add a simple example to the bottom of the TODO document using this feature (make no other changes to that file). Remove the suggestion from PYTHON_GAPS if it is there. Run the full unit test suite to check for regressions.
+