rapydscript-ng 0.7.24 → 0.8.1

package/src/baselib-containers.pyj

@@ -4,6 +4,7 @@
 
 # globals:ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_repr
 
+
 def ρσ_equals(a, b):
     if a is b:
         return True
@@ -21,18 +22,19 @@ def ρσ_equals(a, b):
     if jstype(a) is 'object' and jstype(b) is 'object' and a is not None and b is not None and (
         (a.constructor is Object and b.constructor is Object) or (Object.getPrototypeOf(a) is None and Object.getPrototypeOf(b) is None)
     ):
-            # Do a dict like comparison as this is most likely either a JS has
-            # (Object.create(null) or a JS object used as a hash (v"{}"))
-            akeys, bkeys = Object.keys(a), Object.keys(b)
-            if akeys.length is not bkeys.length:
+        # Do a dict like comparison as this is most likely either a JS has
+        # (Object.create(null) or a JS object used as a hash (v"{}"))
+        akeys, bkeys = Object.keys(a), Object.keys(b)
+        if akeys.length is not bkeys.length:
+            return False
+        for v'var j=0; j < akeys.length; j++':
+            key = akeys[j]
+            if not (a[key] == b[key]):
                 return False
-            for v'var j=0; j < akeys.length; j++':
-                key = akeys[j]
-                if not (a[key] == b[key]):
-                    return False
-            return True
+        return True
     return False
 
+
 def ρσ_not_equals(a, b):
     if a is b:
         return False
@@ -46,168 +48,20 @@ v'var equals = ρσ_equals'
 
 # list {{{
 
-def ρσ_list_extend(iterable):
-    if Array.isArray(iterable) or jstype(iterable) is 'string':
-        # Allocate all new memory in one operation
-        start = this.length
-        this.length += iterable.length
-        for v'var i = 0; i < iterable.length; i++':
-            this[start + i] = iterable[i]  # noqa:undef
-    else:
-        iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
-        result = iterator.next()
-        while not result.done:
-            this.push(result.value)
-            result = iterator.next()
-
-def ρσ_list_index(val, start, stop):
-    start = start or 0
-    if start < 0:
-        start = this.length + start
-    if start < 0:
-        raise ValueError(val + ' is not in list')
-    if stop is undefined:
-        stop = this.length
-    if stop < 0:
-        stop = this.length + stop
-    for v'var i = start; i < stop; i++':
-        if this[i] == val:
-            return i  # noqa:undef
-    raise ValueError(val + ' is not in list')
-
-def ρσ_list_pop(index):
-    if this.length is 0:
-        raise IndexError('list is empty')
-    if index is undefined:
-        index = -1
-    ans = this.splice(index, 1)
-    if not ans.length:
-        raise IndexError('pop index out of range')
-    return ans[0]
-
-def ρσ_list_remove(value):
-    for v'var i = 0; i < this.length; i++':
-        if this[i] == value:
-            this.splice(i, 1)
-            return
-    raise ValueError(value + ' not in list')
-
-def ρσ_list_to_string():
-    return '[' + this.join(', ') + ']'
-
-def ρσ_list_insert(index, val):
-    if index < 0:
-        index += this.length
-    index = min(this.length, max(index, 0))
-    if index is 0:
-        this.unshift(val)
-        return
-    for v'var i = this.length; i > index; i--':
-        this[i] = this[i - 1]  # noqa:undef
-    this[index] = val
-
-def ρσ_list_copy():
-    return ρσ_list_constructor(this)
-
-def ρσ_list_clear():
-    this.length = 0
-
-def ρσ_list_as_array():
-    return Array.prototype.slice.call(this)
-
-def ρσ_list_count(value):
-    return this.reduce(def(n, val): return n + (val is value);, 0)
-
-def ρσ_list_sort_key(value):
-    t = jstype(value)
-    if t is 'string' or t is 'number':
-        return value
-    return value.toString()
-
-def ρσ_list_sort_cmp(a, b, ap, bp):
-    if a < b:
-        return -1
-    if a > b:
-        return 1
-    return ap - bp
-
-def ρσ_list_sort(key=None, reverse=False):
-    key = key or ρσ_list_sort_key
-    mult = -1 if reverse else 1
-    keymap = dict()
-    posmap = dict()
-    for v'var i=0; i < this.length; i++':
-        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));)
-
-def ρσ_list_concat():  # ensure concat() returns an object of type list
-    ans = Array.prototype.concat.apply(this, arguments)
-    ρσ_list_decorate(ans)
-    return ans
-
-def ρσ_list_slice():  # ensure slice() returns an object of type list
-    ans = Array.prototype.slice.apply(this, arguments)
-    ρσ_list_decorate(ans)
-    return ans
 
 def ρσ_list_iterator(value):
     self = this
     return {
-        '_i':-1,
-        '_list':self,
-        'next':def():
+        '_i': -1,
+        '_list': self,
+        'next': def ():
             this._i += 1
             if this._i >= this._list.length:
-                return {'done':True}
-            return {'done':False, 'value':this._list[this._i]}
+                return {'done': True}
+            return {'done': False, 'value': this._list[this._i]}
         ,
     }
 
-def ρσ_list_len():
-    return this.length
-
-def ρσ_list_contains(val):
-    for v'var i = 0; i < this.length; i++':
-        if this[i] == val:
-            return True
-    return False
-
-def ρσ_list_eq(other):
-    if not ρσ_arraylike(other):
-        return False
-    if this.length != other.length:
-        return False
-    for v'var i = 0; i < this.length; i++':
-        if not (this[i] == other[i]):
-            return False
-    return True
-
-def ρσ_list_decorate(ans):
-    ans.append = Array.prototype.push
-    ans.toString = ρσ_list_to_string
-    ans.inspect = ρσ_list_to_string
-    ans.extend = ρσ_list_extend
-    ans.index = ρσ_list_index
-    ans.pypop = ρσ_list_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.slice = ρσ_list_slice
-    ans.as_array = ρσ_list_as_array
-    ans.__len__ = ρσ_list_len
-    ans.__contains__ = ρσ_list_contains
-    ans.__eq__ = ρσ_list_eq
-    ans.constructor = ρσ_list_constructor
-    if jstype(ans[ρσ_iterator_symbol]) is not 'function':
-        # Happens on ES 5 runtimes
-        ans[ρσ_iterator_symbol] = ρσ_list_iterator
-    return ans
 
 def ρσ_list_constructor(iterable):
     if iterable is undefined:
@@ -228,11 +82,165 @@ def ρσ_list_constructor(iterable):
         ans = new Array(iterable)
     else:
         ans = Object.keys(iterable)
-    return ρσ_list_decorate(ans)
+    return ans
 ρσ_list_constructor.__name__ = 'list'
 
+if v'typeof Array.prototype.append' is not 'function':
+    Object.defineProperty(Array.prototype, 'append', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': Array.prototype.push,
+    });
+    Object.defineProperty(Array.prototype, 'extend', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (iterable):
+            if Array.isArray(iterable) or jstype(iterable) is 'string':
+                # Allocate all new memory in one operation
+                start = this.length
+                this.length += iterable.length
+                for v'var i = 0; i < iterable.length; i++':
+                    this[start + i] = iterable[i]  # noqa:undef
+            else:
+                iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+                result = iterator.next()
+                while not result.done:
+                    this.push(result.value)
+                    result = iterator.next()
+    });
+    Object.defineProperty(Array.prototype, 'index', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (val, start, stop):
+            start = start or 0
+            if start < 0:
+                start = this.length + start
+            if start < 0:
+                raise ValueError(val + ' is not in list')
+            if stop is undefined:
+                stop = this.length
+            if stop < 0:
+                stop = this.length + stop
+            for v'var i = start; i < stop; i++':
+                if this[i] == val:
+                    return i  # noqa:undef
+            raise ValueError(val + ' is not in list')
+    });
+    Object.defineProperty(Array.prototype, 'pypop', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (index):
+            if this.length is 0:
+                raise IndexError('list is empty')
+            if index is undefined:
+                index = -1
+            ans = this.splice(index, 1)
+            if not ans.length:
+                raise IndexError('pop index out of range')
+            return ans[0]
+    });
+    Object.defineProperty(Array.prototype, 'remove', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (value):
+            for v'var i = 0; i < this.length; i++':
+                if this[i] == value:
+                    this.splice(i, 1)
+                    return
+            raise ValueError(value + ' not in list')
+    });
+    Object.defineProperty(Array.prototype, 'toString', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): return '[' + this.join(', ') + ']'
+    });
+    Object.defineProperty(Array.prototype, 'inspect', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): return '[' + this.join(', ') + ']'
+    });
+    Object.defineProperty(Array.prototype, 'insert', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (index, val):
+            if index < 0:
+                index += this.length
+            index = min(this.length, max(index, 0))
+            if index is 0:
+                this.unshift(val)
+                return
+            for v'var i = this.length; i > index; i--':
+                this[i] = this[i - 1]  # noqa:undef
+            this[index] = val
+    });
+    Object.defineProperty(Array.prototype, 'copy', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): return ρσ_list_constructor(this)
+    });
+    Object.defineProperty(Array.prototype, 'clear', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): this.length = 0
+    });
+    Object.defineProperty(Array.prototype, 'count', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (value): return this.reduce(def (n, val): return n + (val is value);, 0)
+    });
+    Object.defineProperty(Array.prototype, 'pysort', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (key = None, reverse = False):
+            def _sort_key(value):
+                t = jstype(value)
+                if t is 'string' or t is 'number':
+                    return value
+                return value.toString()
+            def _sort_cmp(a, b, ap, bp):
+                if a < b:
+                    return -1
+                if a > b:
+                    return 1
+                return ap - bp
+            key = key or _sort_key
+            mult = -1 if reverse else 1
+            keymap = dict()
+            posmap = dict()
+            for v'var i=0; i < this.length; i++':
+                k = this[i]  # noqa:undef
+                keymap.set(k, key(k))
+                posmap.set(k, i)
+            this.sort(def (a, b): return mult * _sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
+    });
+    Object.defineProperty(Array.prototype, 'as_array', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): return Array.from (this)
+    });
+    Object.defineProperty(Array.prototype, '__len__', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (): return this.length
+    });
+    Object.defineProperty(Array.prototype, '__contains__', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (val):
+            for v'var i = 0; i < this.length; i++':
+                if this[i] == val:
+                    return True
+            return False
+    });
+    Object.defineProperty(Array.prototype, '__eq__', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': def (other):
+            if not ρσ_arraylike(other):
+                return False
+            if this.length != other.length:
+                return False
+            for v'var i = 0; i < this.length; i++':
+                if not (this[i] == other[i]):
+                    return False
+            return True
+    });
+    Object.defineProperty(Array.prototype, 'constructor', {
+        'writable': False, 'configurable': False, 'enumerable': False,
+        'value': ρσ_list_constructor,
+    });
+
+
+def ρσ_list_decorate(ans):
+    return ans
+
 v'var list = ρσ_list_constructor, list_wrap = ρσ_list_decorate'
 
+
 def sorted(iterable, key=None, reverse=False):
     ans = ρσ_list_constructor(iterable)
     ans.pysort(key, reverse)
@@ -242,34 +250,36 @@ def sorted(iterable, key=None, reverse=False):
 # set {{{
 v'var ρσ_global_object_id = 0, ρσ_set_implementation'
 
+
 def ρσ_set_keyfor(x):
     t = jstype(x)
     if t is 'string' or t is 'number' or t is 'boolean':
         return '_' + t[0] + x
-    if v'x === null': # also matches undefined
-        return "__!@#$0"
+    if v'x === null':  # also matches undefined
+        return '__!@#$0'
     ans = x.ρσ_hash_key_prop
     if ans is undefined:
         v'ans = "_!@#$" + (++ρσ_global_object_id)'
-        Object.defineProperty(x, 'ρσ_hash_key_prop', { 'value': ans })
+        Object.defineProperty(x, 'ρσ_hash_key_prop', {'value': ans})
     return ans
 
+
 def ρσ_set_polyfill():
     this._store = {}
     this.size = 0
 
-ρσ_set_polyfill.prototype.add = def(x):
+ρσ_set_polyfill.prototype.add = def (x):
     key = ρσ_set_keyfor(x)
     if not Object.prototype.hasOwnProperty.call(this._store, key):
         this.size += 1
         this._store[key] = x
     return this
 
-ρσ_set_polyfill.prototype.clear = def(x):
+ρσ_set_polyfill.prototype.clear = def (x):
     this._store = {}
     this.size = 0
 
-ρσ_set_polyfill.prototype.delete = def(x):
+ρσ_set_polyfill.prototype.delete = def (x):
     key = ρσ_set_keyfor(x)
     if Object.prototype.hasOwnProperty.call(this._store, key):
         this.size -= 1
@@ -277,14 +287,14 @@ def ρσ_set_polyfill():
         return True
     return False
 
-ρσ_set_polyfill.prototype.has = def(x):
+ρσ_set_polyfill.prototype.has = def (x):
     return Object.prototype.hasOwnProperty.call(this._store, ρσ_set_keyfor(x))
 
-ρσ_set_polyfill.prototype.values = def(x):
+ρσ_set_polyfill.prototype.values = def (x):
     ans = v"{'_keys': Object.keys(this._store), '_i':-1, '_s':this._store}"
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         return this
-    ans['next'] = def():
+    ans['next'] = def ():
         this._i += 1
         if this._i >= this._keys.length:
             return v"{'done': true}"
@@ -296,6 +306,7 @@ if jstype(Set) is not 'function' or jstype(Set.prototype.delete) is not 'functio
 else:
     v'ρσ_set_implementation = Set'
 
+
 def ρσ_set(iterable):
     if v'this instanceof ρσ_set':
         this.jsset = new ρσ_set_implementation()  # noqa:undef
@@ -323,19 +334,19 @@ def ρσ_set(iterable):
 
 # These are for JavaScript users' convenience
 Object.defineProperties(ρσ_set.prototype, {
-    'length': { 'get': def(): return this.jsset.size; },
-    'size': { 'get': def(): return this.jsset.size; },
+    'length': {'get': def (): return this.jsset.size;},
+    'size': {'get': def (): return this.jsset.size;},
 })
 
-ρσ_set.prototype.__len__ = def(): return this.jsset.size
-ρσ_set.prototype.has = ρσ_set.prototype.__contains__ = def(x): return this.jsset.has(x)
-ρσ_set.prototype.add = def(x): this.jsset.add(x)
-ρσ_set.prototype.clear = def(): this.jsset.clear()
-ρσ_set.prototype.copy = def(): return ρσ_set(this)
-ρσ_set.prototype.discard = def(x): this.jsset.delete(x)
-ρσ_set.prototype[ρσ_iterator_symbol] = def(): return this.jsset.values()
+ρσ_set.prototype.__len__ = def (): return this.jsset.size
+ρσ_set.prototype.has = ρσ_set.prototype.__contains__ = def (x): return this.jsset.has(x)
+ρσ_set.prototype.add = def (x): this.jsset.add(x)
+ρσ_set.prototype.clear = def (): this.jsset.clear()
+ρσ_set.prototype.copy = def (): return ρσ_set(this)
+ρσ_set.prototype.discard = def (x): this.jsset.delete(x)
+ρσ_set.prototype[ρσ_iterator_symbol] = def (): return this.jsset.values()
 
-ρσ_set.prototype.difference = def():
+ρσ_set.prototype.difference = def ():
     ans = new ρσ_set()
     s = ans.jsset
     iterator = this.jsset.values()
@@ -352,7 +363,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return ans
 
-ρσ_set.prototype.difference_update = def():
+ρσ_set.prototype.difference_update = def ():
     s = this.jsset
     remove = v'[]'
     iterator = s.values()
@@ -367,7 +378,7 @@ Object.defineProperties(ρσ_set.prototype, {
     for v'var j = 0; j < remove.length; j++':
         s.delete(remove[j])  # noqa:undef
 
-ρσ_set.prototype.intersection = def():
+ρσ_set.prototype.intersection = def ():
     ans = new ρσ_set()
     s = ans.jsset
     iterator = this.jsset.values()
@@ -384,7 +395,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return ans
 
-ρσ_set.prototype.intersection_update = def():
+ρσ_set.prototype.intersection_update = def ():
     s = this.jsset
     remove = v'[]'
     iterator = s.values()
@@ -399,7 +410,7 @@ Object.defineProperties(ρσ_set.prototype, {
     for v'var j = 0; j < remove.length; j++':
         s.delete(remove[j])  # noqa:undef
 
-ρσ_set.prototype.isdisjoint = def(other):
+ρσ_set.prototype.isdisjoint = def (other):
     iterator = this.jsset.values()
     r = iterator.next()
     while not r.done:
@@ -409,7 +420,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return True
 
-ρσ_set.prototype.issubset = def(other):
+ρσ_set.prototype.issubset = def (other):
     iterator = this.jsset.values()
     r = iterator.next()
     while not r.done:
@@ -419,7 +430,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return True
 
-ρσ_set.prototype.issuperset = def(other):
+ρσ_set.prototype.issuperset = def (other):
     s = this.jsset
     iterator = other.jsset.values()
     r = iterator.next()
@@ -430,7 +441,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return True
 
-ρσ_set.prototype.pop = def():
+ρσ_set.prototype.pop = def ():
     iterator = this.jsset.values()
     r = iterator.next()
     if r.done:
@@ -438,24 +449,24 @@ Object.defineProperties(ρσ_set.prototype, {
     this.jsset.delete(r.value)
     return r.value
 
-ρσ_set.prototype.remove = def(x):
+ρσ_set.prototype.remove = def (x):
     if not this.jsset.delete(x):
         raise KeyError(x.toString())
 
-ρσ_set.prototype.symmetric_difference = def(other):
+ρσ_set.prototype.symmetric_difference = def (other):
     return this.union(other).difference(this.intersection(other))
 
-ρσ_set.prototype.symmetric_difference_update = def(other):
+ρσ_set.prototype.symmetric_difference_update = def (other):
     common = this.intersection(other)
     this.update(other)
     this.difference_update(common)
 
-ρσ_set.prototype.union = def():
+ρσ_set.prototype.union = def ():
     ans = ρσ_set(this)
     ans.update.apply(ans, arguments)
     return ans
 
-ρσ_set.prototype.update = def():
+ρσ_set.prototype.update = def ():
     s = this.jsset
     for v'var i=0; i < arguments.length; i++':
         iterator = arguments[i][ρσ_iterator_symbol]()  # noqa:undef
@@ -464,10 +475,10 @@ Object.defineProperties(ρσ_set.prototype, {
             s.add(r.value)
             r = iterator.next()
 
-ρσ_set.prototype.toString = ρσ_set.prototype.__repr__ = ρσ_set.prototype.__str__ = ρσ_set.prototype.inspect = def():
+ρσ_set.prototype.toString = ρσ_set.prototype.__repr__ = ρσ_set.prototype.__str__ = ρσ_set.prototype.inspect = def ():
     return '{' + list(this).join(', ') + '}'
 
-ρσ_set.prototype.__eq__ = def(other):
+ρσ_set.prototype.__eq__ = def (other):
     if not v'other instanceof this.constructor':
         return False
     if other.size is not this.size:
@@ -482,6 +493,7 @@ Object.defineProperties(ρσ_set.prototype, {
         r = iterator.next()
     return True
 
+
 def ρσ_set_wrap(x):
     ans = new ρσ_set()
     ans.jsset = x
@@ -493,22 +505,23 @@ v'var set = ρσ_set, set_wrap = ρσ_set_wrap'
 # dict {{{
 v'var ρσ_dict_implementation'
 
+
 def ρσ_dict_polyfill():
     this._store = {}
     this.size = 0
 
-ρσ_dict_polyfill.prototype.set = def(x, value):
+ρσ_dict_polyfill.prototype.set = def (x, value):
     key = ρσ_set_keyfor(x)
     if not Object.prototype.hasOwnProperty.call(this._store, key):
         this.size += 1
     this._store[key] = v'[x, value]'
     return this
 
-ρσ_dict_polyfill.prototype.clear = def(x):
+ρσ_dict_polyfill.prototype.clear = def (x):
     this._store = {}
     this.size = 0
 
-ρσ_dict_polyfill.prototype.delete = def(x):
+ρσ_dict_polyfill.prototype.delete = def (x):
     key = ρσ_set_keyfor(x)
     if Object.prototype.hasOwnProperty.call(this._store, key):
         this.size -= 1
@@ -516,42 +529,42 @@ def ρσ_dict_polyfill():
         return True
     return False
 
-ρσ_dict_polyfill.prototype.has = def(x):
+ρσ_dict_polyfill.prototype.has = def (x):
     return Object.prototype.hasOwnProperty.call(this._store, ρσ_set_keyfor(x))
 
-ρσ_dict_polyfill.prototype.get = def(x):
+ρσ_dict_polyfill.prototype.get = def (x):
     try:
         return this._store[ρσ_set_keyfor(x)][1]
     except TypeError:  # Key is not present
         return undefined
 
-ρσ_dict_polyfill.prototype.values = def(x):
+ρσ_dict_polyfill.prototype.values = def (x):
     ans = v"{'_keys': Object.keys(this._store), '_i':-1, '_s':this._store}"
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         return this
-    ans['next'] = def():
+    ans['next'] = def ():
         this._i += 1
         if this._i >= this._keys.length:
             return v"{'done': true}"
         return v"{'done':false, 'value':this._s[this._keys[this._i]][1]}"
     return ans
 
-ρσ_dict_polyfill.prototype.keys = def(x):
+ρσ_dict_polyfill.prototype.keys = def (x):
     ans = v"{'_keys': Object.keys(this._store), '_i':-1, '_s':this._store}"
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         return this
-    ans['next'] = def():
+    ans['next'] = def ():
         this._i += 1
         if this._i >= this._keys.length:
             return v"{'done': true}"
         return v"{'done':false, 'value':this._s[this._keys[this._i]][0]}"
     return ans
 
-ρσ_dict_polyfill.prototype.entries = def(x):
+ρσ_dict_polyfill.prototype.entries = def (x):
     ans = v"{'_keys': Object.keys(this._store), '_i':-1, '_s':this._store}"
-    ans[ρσ_iterator_symbol] = def():
+    ans[ρσ_iterator_symbol] = def ():
         return this
-    ans['next'] = def():
+    ans['next'] = def ():
         this._i += 1
         if this._i >= this._keys.length:
             return v"{'done': true}"
@@ -563,6 +576,7 @@ if jstype(Map) is not 'function' or jstype(Map.prototype.delete) is not 'functio
 else:
     v'ρσ_dict_implementation = Map'
 
+
 def ρσ_dict(iterable, **kw):
     if v'this instanceof ρσ_dict':
         this.jsmap = new ρσ_dict_implementation()  # noqa:undef
@@ -577,20 +591,20 @@ def ρσ_dict(iterable, **kw):
 
 # These are for JavaScript users' convenience
 Object.defineProperties(ρσ_dict.prototype, {
-    'length': { 'get': def(): return this.jsmap.size; },
-    'size': { 'get': def(): return this.jsmap.size; },
+    'length': {'get': def (): return this.jsmap.size;},
+    'size': {'get': def (): return this.jsmap.size;},
 })
 
-ρσ_dict.prototype.__len__ = def(): return this.jsmap.size
-ρσ_dict.prototype.has = ρσ_dict.prototype.__contains__ = def(x): return this.jsmap.has(x)
-ρσ_dict.prototype.set = ρσ_dict.prototype.__setitem__ = def(key, value): this.jsmap.set(key, value)
+ρσ_dict.prototype.__len__ = def (): return this.jsmap.size
+ρσ_dict.prototype.has = ρσ_dict.prototype.__contains__ = def (x): return this.jsmap.has(x)
+ρσ_dict.prototype.set = ρσ_dict.prototype.__setitem__ = def (key, value): this.jsmap.set(key, value)
 ρσ_dict.prototype.__delitem__ = def (key): this.jsmap.delete(key)
-ρσ_dict.prototype.clear = def(): this.jsmap.clear()
-ρσ_dict.prototype.copy = def(): return ρσ_dict(this)
-ρσ_dict.prototype.keys = def(): return this.jsmap.keys()
-ρσ_dict.prototype.values = def(): return this.jsmap.values()
-ρσ_dict.prototype.items = ρσ_dict.prototype.entries = def(): return this.jsmap.entries()
-ρσ_dict.prototype[ρσ_iterator_symbol] = def(): return this.jsmap.keys()
+ρσ_dict.prototype.clear = def (): this.jsmap.clear()
+ρσ_dict.prototype.copy = def (): return ρσ_dict(this)
+ρσ_dict.prototype.keys = def (): return this.jsmap.keys()
+ρσ_dict.prototype.values = def (): return this.jsmap.values()
+ρσ_dict.prototype.items = ρσ_dict.prototype.entries = def (): return this.jsmap.entries()
+ρσ_dict.prototype[ρσ_iterator_symbol] = def (): return this.jsmap.keys()
 
 ρσ_dict.prototype.__getitem__ = def (key):
     ans = this.jsmap.get(key)
@@ -611,7 +625,7 @@ Object.defineProperties(ρσ_dict.prototype, {
         return defval
     return j.get(key)
 
-ρσ_dict.fromkeys = ρσ_dict.prototype.fromkeys = def (iterable, value=None):
+ρσ_dict.fromkeys = ρσ_dict.prototype.fromkeys = def (iterable, value = None):
     ans = ρσ_dict()
     iterator = iter(iterable)
     r = iterator.next()
@@ -675,7 +689,7 @@ Object.defineProperties(ρσ_dict.prototype, {
     if arguments.length > 1:
         ρσ_dict.prototype.update.call(this, arguments[1])
 
-ρσ_dict.prototype.toString = ρσ_dict.prototype.inspect = ρσ_dict.prototype.__str__ = ρσ_dict.prototype.__repr__ = def():
+ρσ_dict.prototype.toString = ρσ_dict.prototype.inspect = ρσ_dict.prototype.__str__ = ρσ_dict.prototype.__repr__ = def ():
     entries = v'[]'
     iterator = this.jsmap.entries()
     r = iterator.next()
@@ -684,7 +698,7 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return '{' + entries.join(', ') + '}'
 
-ρσ_dict.prototype.__eq__ = def(other):
+ρσ_dict.prototype.__eq__ = def (other):
     if not v'(other instanceof this.constructor)':
         return False
     if other.size is not this.size:
@@ -700,7 +714,7 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return True
 
-ρσ_dict.prototype.as_object = def(other):
+ρσ_dict.prototype.as_object = def (other):
     ans = {}
     iterator = this.jsmap.entries()
     r = iterator.next()
@@ -709,6 +723,7 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return ans
 
+
 def ρσ_dict_wrap(x):
     ans = new ρσ_dict()
     ans.jsmap = x