rapydscript-ns 0.8.4 → 0.9.0

package/test/annotations.pyj

@@ -1,80 +1,80 @@
-def add(a: int, b: float):
-    return a + b
-
-assrt.ok(add.__annotations__)
-assrt.equal(add.__annotations__['a'], int)
-assrt.equal(add.__annotations__['b'], float)
-assrt.equal(add.__annotations__['return'], undefined)
-
-def sum(ls: list) -> int:
-    pass
-
-assrt.ok(not (sum.__annotations__ == undefined))
-assrt.deepEqual(sum.__annotations__, {
-    'ls': list,
-    'return': int
-})
-
-def optional(a:int=10):
-    return a
-
-assrt.ok(not (optional.__annotations__ == undefined))
-assrt.equal(optional.__annotations__.a, int)
-assrt.equal(optional.__defaults__.a, 10)
-
-def otherexpr(a:3+4) -> [1, 2]:
-    pass
-
-assrt.ok(not (otherexpr.__annotations__ == undefined))
-assrt.equal(otherexpr.__annotations__['a'], 7)
-assrt.deepEqual(otherexpr.__annotations__['return'], [1, 2])
-
-def basic(x:float):
-    pass
-
-assrt.deepEqual(basic.__annotations__, {
-    'x': float
-})
-
-def kwstarargs(*args:list, **kwargs:dict) -> int:
-    pass
-
-assrt.equal(kwstarargs.__annotations__['return'], int)
-
-def nothing():
-    pass
-
-assrt.ok(nothing.__annotations__ == undefined)
-assrt.throws(def():
-    nothing.__annotations__['return']
-)
-
-test = def(x: int):
-    pass
-
-assrt.deepEqual(test.__annotations__, {
-    'x': int
-})
-
-anonreturn = def() -> 'test':
-    pass
-
-assrt.equal(anonreturn.__annotations__['return'], 'test')
-
-assrt.equal(def asexpr(a: int):
-    a
-.__annotations__['a'], int)
-
-assrt.deepEqual(def(a: int) -> float:
-    a + 10.0
-.__annotations__, {
-    'a': int,
-    'return': float
-})
-
-class A:
-
-    def f(self, a : int, b: 'x') -> float:
-        pass
-
-assrt.deepEqual(A.prototype.f.__annotations__, {'a':int, 'b':'x', 'return': float})
+def add(a: int, b: float):
+    return a + b
+
+assrt.ok(add.__annotations__)
+assrt.equal(add.__annotations__['a'], int)
+assrt.equal(add.__annotations__['b'], float)
+assrt.equal(add.__annotations__['return'], undefined)
+
+def sum(ls: list) -> int:
+    pass
+
+assrt.ok(not (sum.__annotations__ == undefined))
+assrt.deepEqual(sum.__annotations__, {
+    'ls': list,
+    'return': int
+})
+
+def optional(a:int=10):
+    return a
+
+assrt.ok(not (optional.__annotations__ == undefined))
+assrt.equal(optional.__annotations__.a, int)
+assrt.equal(optional.__defaults__.a, 10)
+
+def otherexpr(a:3+4) -> [1, 2]:
+    pass
+
+assrt.ok(not (otherexpr.__annotations__ == undefined))
+assrt.equal(otherexpr.__annotations__['a'], 7)
+assrt.deepEqual(otherexpr.__annotations__['return'], [1, 2])
+
+def basic(x:float):
+    pass
+
+assrt.deepEqual(basic.__annotations__, {
+    'x': float
+})
+
+def kwstarargs(*args:list, **kwargs:dict) -> int:
+    pass
+
+assrt.equal(kwstarargs.__annotations__['return'], int)
+
+def nothing():
+    pass
+
+assrt.ok(nothing.__annotations__ == undefined)
+assrt.throws(def():
+    nothing.__annotations__['return']
+)
+
+test = def(x: int):
+    pass
+
+assrt.deepEqual(test.__annotations__, {
+    'x': int
+})
+
+anonreturn = def() -> 'test':
+    pass
+
+assrt.equal(anonreturn.__annotations__['return'], 'test')
+
+assrt.equal(def asexpr(a: int):
+    a
+.__annotations__['a'], int)
+
+assrt.deepEqual(def(a: int) -> float:
+    a + 10.0
+.__annotations__, {
+    'a': int,
+    'return': float
+})
+
+class A:
+
+    def f(self, a : int, b: 'x') -> float:
+        pass
+
+assrt.deepEqual(A.prototype.f.__annotations__, {'a':int, 'b':'x', 'return': float})

package/test/arithmetic_nostrict.pyj

@@ -0,0 +1,88 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# arithmetic_nostrict.pyj
+# Tests for no_strict_arithmetic: when strict_arithmetic is disabled, incompatible
+# operand types fall back to JavaScript's native coercion instead of raising TypeError.
+# overload_operators must be active for the ρσ_op_*_ns helpers to be dispatched.
+
+from __python__ import overload_operators, no_strict_arithmetic
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+def _no_error(fn):
+    try:
+        fn()
+        return True
+    except:
+        return False
+
+# ── 1. Valid numeric arithmetic still works ───────────────────────────────────
+
+ae(1 + 2, 3)
+ae(10 - 3, 7)
+ae(3 * 4, 12)
+ae(7 / 2, 3.5)
+ae(7 // 2, 3)
+ae(7 % 3, 1)
+ae(2 ** 8, 256)
+
+# ── 2. Valid string concatenation still works ─────────────────────────────────
+
+ae('hello' + ' world', 'hello world')
+
+# ── 3. Valid list concatenation still works ───────────────────────────────────
+
+ade([1, 2] + [3, 4], [1, 2, 3, 4])
+
+# ── 4. String / list repetition still works ──────────────────────────────────
+
+ae('ha' * 3, 'hahaha')
+ae(3 * 'ha', 'hahaha')
+ade([0] * 3, [0, 0, 0])
+
+# ── 5. Mixed types do NOT raise TypeError ─────────────────────────────────────
+
+ok(_no_error(def(): return 1 + 'x';))
+ok(_no_error(def(): return 'x' + 1;))
+ok(_no_error(def(): return 1 - 'x';))
+ok(_no_error(def(): return None + 1;))
+
+# ── 6. JS coercion semantics for mixed types ──────────────────────────────────
+
+# int + str coerces via JS (number becomes string)
+ae(1 + 'x', '1x')
+ae('x' + 2, 'x2')
+
+# number - string coerces string to NaN
+ok(isNaN(1 - 'x'))
+
+# ── 7. Dunder methods still dispatch ──────────────────────────────────────────
+
+class _Meter:
+    def __init__(self, n):
+        self.n = n
+    def __add__(self, other):
+        return _Meter(self.n + other.n)
+    def __mul__(self, scalar):
+        return _Meter(self.n * scalar)
+
+m = _Meter(3) + _Meter(4)
+ae(m.n, 7)
+m2 = _Meter(5) * 2
+ae(m2.n, 10)
+
+# ── 8. Augmented assignment does not raise TypeError ──────────────────────────
+
+ok(_no_error(def():
+    x = 1
+    x += 'oops'
+))
+
+# ── 9. Comparison operators fall through to JS ────────────────────────────────
+
+# JS comparisons with mixed types don't throw; they may produce surprising results
+ok(_no_error(def(): return 1 < 'x';))
+ok(_no_error(def(): return None >= 0;))

package/test/arithmetic_types.pyj

@@ -0,0 +1,169 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# arithmetic_types.pyj
+# Tests for Python-style arithmetic type coercion: incompatible operand types
+# raise TypeError instead of silently coercing (as JavaScript would).
+# overload_operators must be active for the ρσ_op_* helpers to be dispatched.
+
+from __python__ import overload_operators, strict_arithmetic
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+def _raises_type_error(fn):
+    try:
+        fn()
+        return False
+    except TypeError:
+        return True
+
+# ── 1. Valid numeric arithmetic ──────────────────────────────────────────────
+
+ae(1 + 2, 3)
+ae(1.5 + 2.5, 4.0)
+ae(10 - 3, 7)
+ae(3 * 4, 12)
+ae(7 / 2, 3.5)
+ae(7 // 2, 3)
+ae(7 % 3, 1)
+ae(2 ** 8, 256)
+
+# ── 2. Valid string concatenation ────────────────────────────────────────────
+
+ae('hello' + ' world', 'hello world')
+ae('a' + 'b' + 'c', 'abc')
+
+# ── 3. Valid list concatenation ──────────────────────────────────────────────
+
+ade([1, 2] + [3, 4], [1, 2, 3, 4])
+ade([] + [1], [1])
+
+# ── 4. Valid string/list repetition ──────────────────────────────────────────
+
+ae('ha' * 3, 'hahaha')
+ae(3 * 'ha', 'hahaha')
+ade([0] * 3, [0, 0, 0])
+ade(3 * [1, 2], [1, 2, 1, 2, 1, 2])
+
+# ── 5. bool treated as int for arithmetic (Python semantics) ─────────────────
+
+ae(True + 1, 2)
+ae(False + 0, 0)
+ae(True + True, 2)
+ae(True * 5, 5)
+ae(False * 100, 0)
+ae(True + 1.5, 2.5)
+
+# bool * str and bool * list repetition
+ae(True * 'x', 'x')
+ae(False * 'x', '')
+ade(True * [1, 2], [1, 2])
+ade(False * [1, 2], [])
+
+# ── 6. int + str raises TypeError ────────────────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 + 'x';))
+ok(_raises_type_error(def(): return 'x' + 1;))
+ok(_raises_type_error(def(): return 1 + '1';))
+
+# ── 7. numeric - non-numeric raises TypeError ────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 - 'x';))
+ok(_raises_type_error(def(): return 'a' - 'b';))
+ok(_raises_type_error(def(): return [1] - [2];))
+
+# ── 8. numeric / non-numeric raises TypeError ────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 / 'x';))
+ok(_raises_type_error(def(): return 'a' / 2;))
+
+# ── 9. numeric // non-numeric raises TypeError ───────────────────────────────
+
+ok(_raises_type_error(def(): return 5 // 'x';))
+ok(_raises_type_error(def(): return 'a' // 2;))
+
+# ── 10. numeric % non-numeric raises TypeError ───────────────────────────────
+
+ok(_raises_type_error(def(): return 5 % 'x';))
+ok(_raises_type_error(def(): return 'a' % 2;))
+
+# ── 11. numeric ** non-numeric raises TypeError ──────────────────────────────
+
+ok(_raises_type_error(def(): return 2 ** 'x';))
+ok(_raises_type_error(def(): return 'a' ** 2;))
+
+# ── 12. mixed str * non-numeric raises TypeError ─────────────────────────────
+
+ok(_raises_type_error(def(): return 'ha' * 'ha';))
+ok(_raises_type_error(def(): return 'ha' * [1];))
+
+# ── 13. list + non-list raises TypeError ─────────────────────────────────────
+
+ok(_raises_type_error(def(): return [1, 2] + 1;))
+ok(_raises_type_error(def(): return [1, 2] + 'x';))
+ok(_raises_type_error(def(): return 1 + [1, 2];))
+
+# ── 14. None as operand raises TypeError ─────────────────────────────────────
+
+ok(_raises_type_error(def(): return None + 1;))
+ok(_raises_type_error(def(): return 1 + None;))
+ok(_raises_type_error(def(): return None + 'x';))
+
+# ── 15. TypeError message contains operand type names ────────────────────────
+
+msg = ''
+try:
+    v = 1 + 'x'
+except TypeError as e:
+    msg = str(e)
+ok(msg.indexOf('int') >= 0)
+ok(msg.indexOf('str') >= 0)
+ok(msg.indexOf('+') >= 0)
+
+msg2 = ''
+try:
+    v = 2.5 - 'y'
+except TypeError as e:
+    msg2 = str(e)
+ok(msg2.indexOf('float') >= 0)
+ok(msg2.indexOf('str') >= 0)
+ok(msg2.indexOf('-') >= 0)
+
+# ── 16. augmented assignment also raises TypeError ───────────────────────────
+
+ok(_raises_type_error(def():
+    x = 1
+    x += 'oops'
+))
+ok(_raises_type_error(def():
+    x = 'hello'
+    x -= 1
+))
+
+# ── 17. dunder methods still take priority over type checks ──────────────────
+
+class _Meter:
+    def __init__(self, n):
+        self.n = n
+    def __add__(self, other):
+        return _Meter(self.n + other.n)
+    def __mul__(self, scalar):
+        return _Meter(self.n * scalar)
+
+m = _Meter(3) + _Meter(4)
+ae(m.n, 7)
+m2 = _Meter(5) * 2
+ae(m2.n, 10)
+
+# ── 18. radd/rsub reflected methods still work ───────────────────────────────
+
+class _Vec:
+    def __init__(self, x):
+        self.x = x
+    def __radd__(self, other):
+        return _Vec(other + self.x)
+
+v = 10 + _Vec(5)
+ae(v.x, 15)

package/test/baselib.pyj

@@ -99,6 +99,20 @@ assrt.deepEqual(list(map(def(a):return a*2;, iter([1, 2]))), [2, 4])
 assrt.deepEqual(list(filter(def(a):return a > 1;, [1, 2])), [2])
 assrt.deepEqual(list(filter(def(a):return a > 1;, iter([1, 2]))), [2])
 assrt.deepEqual(list(zip([1,2], [3,4])), [[1,3], [2, 4]])
+assrt.deepEqual(list(zip([1,2], [3,4], strict=True)), [[1,3], [2, 4]])
+assrt.deepEqual(list(zip(strict=True)), [])
+_zip_err = False
+try:
+    list(zip([1,2], [3], strict=True))
+except:
+    _zip_err = True
+assrt.ok(_zip_err)
+_zip_err2 = False
+try:
+    list(zip([1], [3,4], strict=True))
+except:
+    _zip_err2 = True
+assrt.ok(_zip_err2)
 
 # lists
 a = [1, 2]
@@ -317,3 +331,80 @@ assrt.equal(all(iter([1, 2, 3])), True)
 assrt.equal(all(iter([1, 0, 3])), False)
 assrt.equal(all(range(1, 4)), True)
 assrt.equal(all(range(0, 3)), False)
+
+# complex() builtin and j-literal syntax
+c1 = complex(3, 4)
+assrt.equal(c1.real, 3)
+assrt.equal(c1.imag, 4)
+
+# j literal syntax
+c2 = 4j
+assrt.equal(c2.real, 0)
+assrt.equal(c2.imag, 4)
+
+# 3+4j literal — + goes through ρσ_list_add which dispatches __add__
+c3 = 3+4j
+assrt.equal(c3.real, 3)
+assrt.equal(c3.imag, 4)
+
+# abs() dispatches to __abs__
+assrt.equal(abs(complex(3, 4)), 5.0)
+assrt.equal(abs(complex(-5, 0)), 5)
+
+# arithmetic via dunder methods (no overload_operators needed)
+assrt.ok(complex(1, 2).__add__(complex(3, 4)) == complex(4, 6))
+assrt.ok(complex(5, 6).__sub__(complex(3, 4)) == complex(2, 2))
+assrt.ok(complex(1, 2).__mul__(complex(3, 4)) == complex(-5, 10))
+assrt.ok(complex(2, 0).__truediv__(complex(4, 0)) == complex(0.5, 0))
+
+# mixed complex + number
+assrt.ok(complex(3, 4) + 1 == complex(4, 4))  # ρσ_list_add → __add__
+assrt.ok(complex(3, 4).__radd__(1) == complex(4, 4))
+assrt.ok(complex(3, 4).__sub__(1) == complex(2, 4))
+assrt.ok(complex(3, 4).__rmul__(2) == complex(6, 8))
+assrt.ok(complex(6, 8).__truediv__(2) == complex(3, 4))
+
+# 1 + complex — ρσ_list_add dispatches __radd__ when left has no __add__
+assrt.ok(1 + complex(3, 4) == complex(4, 4))
+
+# unary via dunder
+assrt.ok(complex(3, 4).__neg__() == complex(-3, -4))
+assrt.ok(complex(3, 4).__pos__() == complex(3, 4))
+
+# conjugate
+assrt.ok(complex(3, 4).conjugate() == complex(3, -4))
+
+# zero-argument form
+assrt.ok(complex() == complex(0, 0))
+
+# single-argument number
+assrt.ok(complex(5) == complex(5, 0))
+
+# single-argument string
+assrt.ok(complex('3+4j') == complex(3, 4))
+assrt.ok(complex('3-4j') == complex(3, -4))
+assrt.ok(complex('4j') == complex(0, 4))
+assrt.ok(complex('3') == complex(3, 0))
+assrt.ok(complex('j') == complex(0, 1))
+assrt.ok(complex('-j') == complex(0, -1))
+
+# isinstance
+assrt.ok(isinstance(complex(1, 2), complex))
+assrt.ok(not isinstance(42, complex))
+
+# bool — __bool__ dispatch works, and truthiness is correct in conditions
+assrt.ok(complex(0, 0).__bool__() is False)
+assrt.ok(complex(1, 0).__bool__() is True)
+assrt.ok(complex(0, 1).__bool__() is True)
+
+# repr / str
+assrt.equal(repr(complex(0, 0)), '0j')
+assrt.equal(repr(complex(1, 0)), '(1+0j)')
+assrt.equal(repr(complex(0, 1)), '1j')
+assrt.equal(repr(complex(3, 4)), '(3+4j)')
+assrt.equal(repr(complex(3, -4)), '(3-4j)')
+assrt.equal(str(complex(3, 4)), '(3+4j)')
+
+# abs() still works on numbers
+assrt.equal(abs(-5), 5)
+assrt.equal(abs(3.0), 3.0)