Use gensym where appropriate.

Technologicat · Technologicat · commit 81229a892799 · 2020-03-05T17:44:02.000+02:00
Due to performance reasons, there are still places where it's better to use
`object()`, if the human-readable label is not necessary. One place in
particular that needs to be fast is `arity.resolve_bindings`, because
memoizers must call it every time when handling an incoming call.

Using `gensym` there leads to a significant performance hit in `fix`, noticeable
in the tests (~4-5 seconds instead of 1-2 to run `test_fix.py`, reproducible
not only on CPython, but also on PyPy3).
diff --git a/unpythonic/arity.py b/unpythonic/arity.py
@@ -16,13 +16,14 @@
 import operator
 
 from .dynassign import dyn, make_dynvar
+from .symbol import gensym
 
 make_dynvar(resolve_bindings_tuplify=False)
 
 try:  # Python 3.5+
     from operator import matmul, imatmul
 except ImportError:
-    NoSuchBuiltin = object()
+    NoSuchBuiltin = gensym("NoSuchBuiltin")
     matmul = imatmul = NoSuchBuiltin
 
 class UnknownArity(ValueError):
@@ -379,7 +380,7 @@ def f(a):
 
     # https://docs.python.org/3/reference/compound_stmts.html#function-definitions
     # https://docs.python.org/3/reference/expressions.html#calls
-    unassigned = object()  # gensym
+    unassigned = object()  # gensym("unassigned"), but object() is much faster and we don't need the label.
     slots = [unassigned for _ in range(len(params))]  # yes, varparams too
 
     # fill from positional arguments
diff --git a/unpythonic/ec.py b/unpythonic/ec.py
@@ -31,6 +31,7 @@
 from functools import wraps
 
 from .regutil import register_decorator
+# from .symbol import gensym
 
 def escape(value, tag=None, allow_catchall=True):
     """Alias for `throw`, for backward compatibility.
@@ -263,7 +264,7 @@ def inner():
     Similar usage is valid for named functions, too.
     """
     # Create a process-wide unique id to tag the ec:
-    anchor = object()
+    anchor = object()  # gensym("anchor"), but object() is much faster and we don't need the label.
     uid = id(anchor)
     # Closure property important here. "ec" itself lives as long as someone
     # retains a reference to it. It's a first-class value; the callee could
diff --git a/unpythonic/lazyutil.py b/unpythonic/lazyutil.py
@@ -9,11 +9,12 @@
 
 from .regutil import register_decorator
 from .dynassign import make_dynvar
+from .symbol import gensym
 
 # HACK: break dependency loop llist -> fun -> lazyutil -> collections -> llist
 #from .collections import mogrify
 _init_done = False
-jump = object()  # gensym, nothing else "is" this
+jump = gensym("jump")
 def _init_module():  # called by unpythonic.__init__ when otherwise done
     global mogrify, jump, _init_done
     from .collections import mogrify
diff --git a/unpythonic/llist.py b/unpythonic/llist.py
@@ -12,6 +12,7 @@
 from .fold import foldr, foldl
 from .it import rev
 from .singleton import Singleton
+# from .symbol import gensym
 
 # explicit list better for tooling support
 _exports = ["cons", "nil",
@@ -250,7 +251,7 @@ def __eq__(self, other):
         if isinstance(other, cons):
             try:  # duck test linked lists
                 ia, ib = (LinkedListIterator(x) for x in (self, other))
-                fill = object()  # essentially gensym
+                fill = object()  # gensym("fill"), but object() is much faster and we don't need the label.
                 for a, b in zip_longest(ia, ib, fillvalue=fill):
                     if a != b:
                         return False
diff --git a/unpythonic/net/server.py b/unpythonic/net/server.py
@@ -145,6 +145,7 @@
 
 from ..collections import ThreadLocalBox, Shim
 from ..misc import async_raise, namelambda
+from ..symbol import sym
 
 from .util import ReuseAddrThreadingTCPServer, socketsource
 from .msg import MessageDecoder
@@ -228,7 +229,9 @@ def halt(doit=True):
     server_print(msg)
 
 _bg_results = {}
-_bg_running, _bg_success, _bg_fail = [object() for _ in range(3)]
+_bg_running = sym("_bg_running")
+_bg_success = sym("_bg_success")
+_bg_fail = sym("bg_fail")
 def bg(thunk):
     """Spawn a thread to run `thunk` in the background. Return the thread object.
 
