rapydscript-ns 0.8.1 → 0.8.3

package/language-service/language-service.d.ts

@@ -0,0 +1,40 @@
+// language-service.d.ts — Ambient type declarations for language-service.js
+// The actual implementation lives in language-service.js (bundled, do not edit directly).
+
+export interface WebReplInstance {
+  in_block_mode: boolean;
+  compile(code: string, opts?: Record<string, unknown>): string;
+  compile_mapped(code: string, opts?: Record<string, unknown>): { code: string; sourceMap: string };
+  runjs(code: string): unknown;
+  replace_print(writeLine: (...args: unknown[]) => void): void;
+  is_input_complete(source: string): boolean;
+  init_completions(completelib: unknown): void;
+  find_completions(line: string): unknown;
+}
+
+export interface RapydScriptOptions {
+  compiler?: unknown;
+  virtualFiles?: Record<string, string>;
+  stdlibFiles?: Record<string, string>;
+  dtsFiles?: Array<{ name: string; content: string }>;
+  parseDelay?: number;
+  extraBuiltins?: Record<string, true>;
+  pythonFlags?: string;
+  pythonize_strings?: boolean;
+  loadDts?: (name: string) => string | Promise<string>;
+}
+
+export declare class RapydScriptLanguageService {
+  constructor(monaco: unknown, options: RapydScriptOptions);
+
+  setVirtualFiles(files: Record<string, string>): void;
+  removeVirtualFile(name: string): void;
+  addGlobals(names: string[]): void;
+  getScopeMap(model: unknown): unknown | null;
+  addDts(name: string, dtsText: string): void;
+  loadDts(name: string): Promise<void>;
+  dispose(): void;
+}
+
+export declare function registerRapydScript(monaco: unknown, options?: RapydScriptOptions): RapydScriptLanguageService;
+export declare function web_repl(): WebReplInstance;

package/package.json

@@ -2,6 +2,11 @@
   "name": "rapydscript-ns",
   "description": "Pythonic JavaScript that doesn't suck",
   "homepage": "https://github.com/ficocelliguy/rapydscript-ns",
+  "version": "0.8.3",
+  "license": "BSD-2-Clause",
+  "engines": {
+    "node": ">=0.12.0"
+  },
   "keywords": [
     "javascript",
     "rapydscript",
@@ -11,7 +16,10 @@
   "main": "tools/compiler.js",
   "exports": {
     ".": "./tools/compiler.js",
-    "./language-service": "./web-repl/language-service.js"
+    "./language-service": {
+      "types": "./language-service/language-service.d.ts",
+      "default": "./language-service/index.js"
+    }
   },
   "scripts": {
     "test": "node bin/rapydscript self --complete --test && npm run test:unit && npm run test:ls",
@@ -23,11 +31,6 @@
     "build": "rm -rf **/*pyj-cached dev && node bin/rapydscript self --complete && node bin/web-repl-export web-repl && node tools/build-language-service.js",
     "prepublishOnly": "node tools/build-language-service.js"
   },
-  "version": "0.8.1",
-  "license": "BSD-2-Clause",
-  "engines": {
-    "node": ">=0.12.0"
-  },
   "maintainers": [
     {
       "name": "Michael Ficocelli",
@@ -39,12 +42,8 @@
     "url": "https://github.com/ficocelliguy/rapydscript-ns.git"
   },
   "dependencies": {
-    "regenerator": ">= 0.12.1",
     "uglify-js": ">= 3.0.15"
   },
-  "optionalDependencies": {
-    "v8-profiler": ">= 5.2.9"
-  },
   "bin": {
     "rapydscript": "bin/rapydscript"
   }

package/src/ast.pyj

@@ -159,6 +159,7 @@ class AST_Assert(AST_Statement):
     properties = {
         'condition': "[AST_Node] the expression that should be tested",
         'message': "[AST_Node*] the expression that is the error message or None",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -213,7 +214,8 @@ class AST_StatementWithBody(AST_Statement):
 class AST_DWLoop(AST_StatementWithBody):
     "Base class for do/while statements"
     properties = {
-        'condition': "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
+        'condition': "[AST_Node] the loop condition.  Should not be instanceof AST_Statement",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -227,13 +229,25 @@ class AST_Do(AST_DWLoop):
 
 class AST_While(AST_DWLoop):
     "A `while` statement"
+    properties = {
+        'belse': "[AST_Else?] the `else` clause, run when loop exits without `break`"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.condition._walk(visitor)
+            self.body._walk(visitor)
+            if self.belse:
+                self.belse._walk(visitor)
+        )
 
 class AST_ForIn(AST_StatementWithBody):
     "A `for ... in` statement"
     properties = {
         'init': "[AST_Node] the `for/in` initialization code",
         'name': "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
-        'object': "[AST_Node] the object that we're looping through"
+        'object': "[AST_Node] the object that we're looping through",
+        'belse': "[AST_Else?] the `else` clause, run when no break occurred"
     }
 
     def _walk(self, visitor):
@@ -243,6 +257,8 @@ class AST_ForIn(AST_StatementWithBody):
             self.object._walk(visitor)
             if self.body:
                 self.body._walk(visitor)
+            if self.belse:
+                self.belse._walk(visitor)
         )
 
 class AST_ForJS(AST_StatementWithBody):
@@ -647,6 +663,9 @@ class AST_Await(AST_Node):
 
 class AST_Throw(AST_Exit):
     "A `throw` statement"
+    properties = {
+        'cause': "[AST_Node?] the __cause__ of the exception (from `raise X from Y`); may be None"
+    }
 
 class AST_LoopControl(AST_Jump):
     "Base class for loop control statements (`break` and `continue`)"
@@ -663,7 +682,8 @@ class AST_If(AST_StatementWithBody):
     "A `if` statement"
     properties = {
         'condition': "[AST_Node] the `if` condition",
-        'alternative': "[AST_Statement?] the `else` part, or null if not present"
+        'alternative': "[AST_Statement?] the `else` part, or null if not present",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -767,7 +787,8 @@ class AST_BaseCall(AST_Node):
 class AST_Call(AST_BaseCall):
     "A function call expression"
     properties = {
-        'expression': "[AST_Node] expression to invoke as function"
+        'expression': "[AST_Node] expression to invoke as function",
+        'python_truthiness': "[bool] Whether to use Python truthiness for __call__ dispatch"
     }
 
     def _walk(self, visitor):
@@ -941,7 +962,8 @@ class AST_Unary(AST_Node):
         'operator': "[string] the operator",
         'expression': "[AST_Node] expression that this unary operator applies to",
         'parenthesized': "[bool] Whether this unary expression was parenthesized",
-        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch"
+        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -958,7 +980,8 @@ class AST_Binary(AST_Node):
         'left': "[AST_Node] left-hand side expression",
         'operator': "[string] the operator",
         'right': "[AST_Node] right-hand side expression",
-        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch"
+        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -987,6 +1010,7 @@ class AST_Conditional(AST_Node):
         'condition': "[AST_Node]",
         'consequent': "[AST_Node]",
         'alternative': "[AST_Node]",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):

package/src/baselib-builtins.pyj

@@ -5,7 +5,21 @@
 # globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains
 
 def ρσ_bool(val):
-    return v'!!val'
+    # Python truthiness — written entirely with verbatim JS so that the
+    # compiled ρσ_bool function never calls itself (no bootstrap recursion).
+    v'if (val === null || val === undefined) return false'
+    v'var ρσ_bool_t = typeof val'
+    v'if (ρσ_bool_t === "boolean") return val'
+    v'if (ρσ_bool_t === "number") return val !== 0'
+    v'if (ρσ_bool_t === "string") return val.length > 0'
+    v'if (ρσ_bool_t === "function") return true'
+    v'if (val.constructor && val.constructor.prototype === val) return true'
+    v'if (typeof val.__bool__ === "function") return !!val.__bool__()'
+    v'if (Array.isArray(val)) return val.length > 0'
+    v'if (typeof val.__len__ === "function") return val.__len__() > 0'
+    v'if ((typeof Set === "function" && val instanceof Set) || (typeof Map === "function" && val instanceof Map)) return val.size > 0'
+    v'if (!val.constructor || val.constructor === Object) return Object.keys(val).length > 0'
+    return True
 
 def ρσ_print(*args, **kwargs):
     if v'typeof console' is 'object':
@@ -73,7 +87,24 @@ def ρσ_chr(code):
     return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF))
 
 def ρσ_callable(x):
-    return v'typeof x === "function"'
+    return v'typeof x === "function" || (x !== null && x !== undefined && typeof x.__call__ === "function")'
+
+def ρσ_callable_call(fn):
+    # Dispatch fn(args): check __call__ first (callable objects), then direct call.
+    # __call__ is checked first so callable objects (not functions) are dispatched correctly.
+    args = v'Array.prototype.slice.call(arguments, 1)'
+    if v'fn !== null && fn !== undefined && typeof fn.__call__ === "function"':
+        return v'fn.__call__.apply(fn, args)'
+    if v'typeof fn === "function"':
+        return v'fn.apply(undefined, args)'
+    raise TypeError('object is not callable')
+
+
+def ρσ_round(x, ndigits):
+    if ndigits is undefined or ndigits is 0:
+        return Math.round(x)
+    factor = Math.pow(10, ndigits)
+    return Math.round(x * factor) / factor
 
 def ρσ_bin(x):
     if jstype(x) is not 'number' or x % 1 is not 0:
@@ -95,15 +126,17 @@ def ρσ_hex(x):
         ans = '0x' + ans
     return ans
 
-def ρσ_enumerate(iterable):
-    ans = v'{"_i":-1}'
+def ρσ_enumerate(iterable, start):
+    offset = 0 if start is undefined else start
+    ans = {'_i': offset - 1}
     ans[ρσ_iterator_symbol] = def():
         return this
     if ρσ_arraylike(iterable):
         ans['next'] = def():
                 this._i += 1
-                if this._i < iterable.length:
-                    return v"{'done':false, 'value':[this._i, iterable[this._i]]}"
+                idx = this._i - offset
+                if idx < iterable.length:
+                    return {'done': False, 'value': [this._i, iterable[idx]]}
                 return v"{'done':true}"
         return ans
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
@@ -114,9 +147,9 @@ def ρσ_enumerate(iterable):
             if r.done:
                 return v"{'done':true}"
             this._i += 1
-            return v"{'done':false, 'value':[this._i, r.value]}"
+            return {'done': False, 'value': [this._i, r.value]}
         return ans
-    return ρσ_enumerate(Object.keys(iterable))
+    return ρσ_enumerate(Object.keys(iterable), start)
 
 def ρσ_reversed(iterable):
     if ρσ_arraylike(iterable):
@@ -131,7 +164,22 @@ def ρσ_reversed(iterable):
         return ans
     raise TypeError('reversed() can only be called on arrays or strings')
 
-def ρσ_iter(iterable):
+def ρσ_iter(iterable, sentinel):
+    # Two-argument form: iter(callable, sentinel) — call repeatedly until sentinel is returned
+    if arguments.length >= 2:
+        callable_ = iterable
+        ans = v'{"_callable":callable_,"_sentinel":sentinel,"_done":false}'
+        ans[ρσ_iterator_symbol] = def():
+            return this
+        ans['next'] = def():
+            if this._done:
+                return v"{'done':true}"
+            val = ρσ_callable_call(this._callable)
+            if v'val === this._sentinel':
+                this._done = True
+                return v"{'done':true}"
+            return v"{'done':false,'value':val}"
+        return ans
     # Generate a JavaScript iterator object from iterable
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
         return iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
@@ -244,6 +292,67 @@ def ρσ_type(x):
     return x.constructor
 
 
+def ρσ_issubclass(cls, base):
+    if Array.isArray(base):
+        for b in base:
+            if ρσ_issubclass(cls, b):
+                return True
+        return False
+    if jstype(cls) is not 'function':
+        raise TypeError('issubclass() arg 1 must be a class')
+    if jstype(base) is not 'function':
+        raise TypeError('issubclass() arg 2 must be a class')
+    if cls is base:
+        return True
+    v'var proto = cls.prototype; while (proto !== null && proto !== undefined) { if (proto === base.prototype) return true; proto = Object.getPrototypeOf(proto); }'
+    return False
+
+
+v'var ρσ_hash_id_counter = 0'
+
+def ρσ_hash(obj):
+    v'var ρσ_t = typeof obj'
+    v'if (obj === null || obj === undefined) return 0'
+    v'if (ρσ_t === "boolean") return obj ? 1 : 0'
+    v'if (ρσ_t === "number") { return (obj === Math.floor(obj)) ? (obj | 0) : ((obj * 2654435761) | 0); }'
+    v'''if (ρσ_t === "string") {
+        var ρσ_h = 5381;
+        for (var ρσ_i = 0; ρσ_i < obj.length; ρσ_i++) {
+            ρσ_h = (((ρσ_h << 5) + ρσ_h) ^ obj.charCodeAt(ρσ_i)) | 0;
+        }
+        return ρσ_h;
+    }'''
+    v'if (typeof obj.__hash__ === "function") return obj.__hash__()'
+    v'if (Array.isArray(obj)) throw new TypeError("unhashable type: \'list\'")'
+    v'if (typeof ρσ_set === "function" && obj instanceof ρσ_set) throw new TypeError("unhashable type: \'set\'")'
+    v'if (typeof Set === "function" && obj instanceof Set) throw new TypeError("unhashable type: \'set\'")'
+    v'if (typeof ρσ_dict === "function" && obj instanceof ρσ_dict) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (typeof Map === "function" && obj instanceof Map) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (!obj.constructor || obj.constructor === Object) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (obj.ρσ_object_id === undefined) obj.ρσ_object_id = ++ρσ_hash_id_counter'
+    v'return obj.ρσ_object_id'
+
+
+def ρσ_next(iterator, defval):
+    if iterator is None or iterator is undefined:
+        raise TypeError('object is not an iterator')
+    if jstype(iterator.next) is 'function':
+        r = iterator.next()
+        if r.done:
+            if arguments.length > 1:
+                return defval
+            raise StopIteration()
+        return r.value
+    if jstype(iterator.__next__) is 'function':
+        try:
+            return iterator.__next__()
+        except StopIteration:
+            if arguments.length > 1:
+                return defval
+            raise
+    raise TypeError("object is not an iterator")
+
+
 def ρσ_divmod(x, y):
     if y is 0:
         raise ZeroDivisionError('integer division or modulo by zero')
@@ -269,11 +378,72 @@ def ρσ_max(*args, **kwargs):
     raise TypeError('expected at least one argument')
 
 
+class ρσ_slice:
+    def __init__(self, start_or_stop, stop, step):
+        if arguments.length is 1:
+            self.start = None
+            self.stop = start_or_stop
+            self.step = None
+        elif arguments.length is 2:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = None
+        else:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = step
+
+    def indices(self, length):
+        step = 1 if self.step is None else self.step
+        if step is 0:
+            raise ValueError('slice step cannot be zero')
+        if step > 0:
+            lower = 0
+            upper = length
+            start = lower if self.start is None else self.start
+            stop  = upper if self.stop  is None else self.stop
+        else:
+            lower = -1
+            upper = length - 1
+            start = upper if self.start is None else self.start
+            stop  = lower if self.stop  is None else self.stop
+        # Only clamp values that were explicitly provided (None defaults are already correct).
+        if self.start is not None:
+            if start < 0:
+                start = max(start + length, lower)
+            if start > upper:
+                start = upper
+        if self.stop is not None:
+            if stop < 0:
+                stop = max(stop + length, lower)
+            if stop > upper:
+                stop = upper
+        return start, stop, step
+
+    def __repr__(self):
+        s = 'None' if self.start is None else String(self.start)
+        stop = 'None' if self.stop is None else String(self.stop)
+        step = 'None' if self.step is None else String(self.step)
+        return 'slice(' + s + ', ' + stop + ', ' + step + ')'
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        if not v'other instanceof ρσ_slice':
+            return False
+        return self.start is other.start and self.stop is other.stop and self.step is other.step
+
+    def __hash__(self):
+        raise TypeError("unhashable type: 'slice'")
+
+
 v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
 v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
 v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
-v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable'
+v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable, round = ρσ_round'
 v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, len = ρσ_len'
-v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr'
+v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr, issubclass = ρσ_issubclass, hash = ρσ_hash, next = ρσ_next'
 v'var ρσ_Ellipsis = Object.freeze({toString: function(){return "Ellipsis";}, __repr__: function(){return "Ellipsis";}})'
 v'var Ellipsis = ρσ_Ellipsis'
+v'var slice = ρσ_slice'

package/src/baselib-containers.pyj

@@ -140,7 +140,7 @@ def ρσ_list_sort(key=None, reverse=False):
         k = this[i]  # noqa:undef
         keymap.set(k, key(k))
         posmap.set(k, i)
-    this.sort(def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
+    Array.prototype.sort.call(this, def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
 
 def ρσ_list_concat():  # ensure concat() returns an object of type list
     ans = Array.prototype.concat.apply(this, arguments)
@@ -190,14 +190,18 @@ def ρσ_list_decorate(ans):
     ans.inspect = ρσ_list_to_string
     ans.extend = ρσ_list_extend
     ans.index = ρσ_list_index
-    ans.pypop = ρσ_list_pop
+    ans.jspop = Array.prototype.pop      # native JS pop (no bounds check, ignores args)
+    ans.pop = ρσ_list_pop                # Python pop (bounds-checked, supports negative index)
+    ans.pypop = ρσ_list_pop              # backward-compat alias for pop
     ans.remove = ρσ_list_remove
     ans.insert = ρσ_list_insert
     ans.copy = ρσ_list_copy
     ans.clear = ρσ_list_clear
     ans.count = ρσ_list_count
     ans.concat = ρσ_list_concat
-    ans.pysort = ρσ_list_sort
+    ans.jssort = Array.prototype.sort    # native JS sort (lexicographic by default)
+    ans.sort = ρσ_list_sort              # Python sort (numeric by default)
+    ans.pysort = ρσ_list_sort            # backward-compat alias for sort
     ans.slice = ρσ_list_slice
     ans.as_array = ρσ_list_as_array
     ans.__len__ = ρσ_list_len
@@ -235,7 +239,7 @@ v'var list = ρσ_list_constructor, list_wrap = ρσ_list_decorate'
 
 def sorted(iterable, key=None, reverse=False):
     ans = ρσ_list_constructor(iterable)
-    ans.pysort(key, reverse)
+    ans.sort(key, reverse)
     return ans
 # }}}
 
@@ -468,7 +472,7 @@ Object.defineProperties(ρσ_set.prototype, {
     return '{' + list(this).join(', ') + '}'
 
 ρσ_set.prototype.__eq__ = def(other):
-    if not v'other instanceof this.constructor':
+    if v'!other || !other.jsset':
         return False
     if other.size is not this.size:
         return False
@@ -490,6 +494,142 @@ def ρσ_set_wrap(x):
 v'var set = ρσ_set, set_wrap = ρσ_set_wrap'
 # }}}
 
+# frozenset {{{
+def ρσ_frozenset(iterable):
+    if v'this instanceof ρσ_frozenset':
+        this.jsset = new ρσ_set_implementation()  # noqa:undef
+        ans = this
+        if iterable is undefined:
+            return ans
+        s = ans.jsset
+        if ρσ_arraylike(iterable):
+            for v'var i = 0; i < iterable.length; i++':
+                s.add(iterable[i])
+        elif jstype(iterable[ρσ_iterator_symbol]) is 'function':
+            iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+            result = iterator.next()
+            while not result.done:
+                s.add(result.value)
+                result = iterator.next()
+        else:
+            keys = Object.keys(iterable)
+            for v'var j=0; j < keys.length; j++':
+                s.add(keys[j])
+        return ans
+    else:
+        return new ρσ_frozenset(iterable)
+ρσ_frozenset.prototype.__name__ = 'frozenset'
+
+Object.defineProperties(ρσ_frozenset.prototype, {
+    'length': { 'get': def(): return this.jsset.size; },
+    'size': { 'get': def(): return this.jsset.size; },
+})
+
+ρσ_frozenset.prototype.__len__ = def(): return this.jsset.size
+ρσ_frozenset.prototype.has = ρσ_frozenset.prototype.__contains__ = def(x): return this.jsset.has(x)
+ρσ_frozenset.prototype.copy = def(): return ρσ_frozenset(this)
+ρσ_frozenset.prototype[ρσ_iterator_symbol] = def(): return this.jsset.values()
+
+ρσ_frozenset.prototype.difference = def():
+    ans = new ρσ_frozenset()
+    s = ans.jsset
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        has = False
+        for v'var i = 0; i < arguments.length; i++':
+            if arguments[i].has(x):  # noqa:undef
+                has = True
+                break
+        if not has:
+            s.add(x)
+        r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.intersection = def():
+    ans = new ρσ_frozenset()
+    s = ans.jsset
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        has = True
+        for v'var i = 0; i < arguments.length; i++':
+            if not arguments[i].has(x):  # noqa:undef
+                has = False
+                break
+        if has:
+            s.add(x)
+        r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.isdisjoint = def(other):
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if other.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.issubset = def(other):
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if not other.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.issuperset = def(other):
+    s = this.jsset
+    iterator = other[ρσ_iterator_symbol]()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if not s.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.symmetric_difference = def(other):
+    return this.union(other).difference(this.intersection(other))
+
+ρσ_frozenset.prototype.union = def():
+    ans = ρσ_frozenset(this)
+    s = ans.jsset
+    for v'var i=0; i < arguments.length; i++':
+        iterator = arguments[i][ρσ_iterator_symbol]()  # noqa:undef
+        r = iterator.next()
+        while not r.done:
+            s.add(r.value)
+            r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.toString = ρσ_frozenset.prototype.__repr__ = ρσ_frozenset.prototype.__str__ = ρσ_frozenset.prototype.inspect = def():
+    return 'frozenset({' + list(this).join(', ') + '})'
+
+ρσ_frozenset.prototype.__eq__ = def(other):
+    if v'!other || !other.jsset':
+        return False
+    if other.size is not this.size:
+        return False
+    if other.size is 0:
+        return True
+    iterator = other[ρσ_iterator_symbol]()
+    r = iterator.next()
+    while not r.done:
+        if not this.has(r.value):
+            return False
+        r = iterator.next()
+    return True
+
+v'var frozenset = ρσ_frozenset'
+# }}}
+
 # dict {{{
 v'var ρσ_dict_implementation'
 
@@ -704,6 +844,15 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return True
 
+ρσ_dict.prototype.__or__ = def(other):
+    result = ρσ_dict(this)
+    result.update(other)
+    return result
+
+ρσ_dict.prototype.__ior__ = def(other):
+    this.update(other)
+    return this
+
 ρσ_dict.prototype.as_object = def(other):
     ans = {}
     iterator = this.jsmap.entries()

package/src/baselib-errors.pyj

@@ -35,3 +35,6 @@ class AssertionError(Exception):
 
 class ZeroDivisionError(Exception):
     pass
+
+class StopIteration(Exception):
+    pass