naming: setescape should use 'tags' since it accepts a tuple

Technologicat · Technologicat · commit 11dc899711dc · 2018-07-31T18:04:31.000+03:00
diff --git a/README.md b/README.md
@@ -560,10 +560,10 @@ To make this work with lambdas, and for uniformity of syntax, **in trampolined f
 For more control, both ``@setescape`` points and ``escape`` instances can be tagged:
 
 ```python
-@setescape(tag="foo")  # setescape point tag can be single value or tuple (tuples OR'd, like isinstance())
+@setescape(tags="foo")  # setescape point tags can be single value or tuple (tuples OR'd, like isinstance())
 def foo():
     @immediate
-    @setescape(tag="bar")
+    @setescape(tags="bar")
     def bar():
         @looped
         def s(loop, acc=0, i=0):
diff --git a/tour.py b/tour.py
@@ -368,11 +368,11 @@ def s(loop, acc=0, i=0):
     assert f() == 15
 
     # tagged escapes to control where the escape is sent:
-    # setescape point tag can be single value or tuple (tuples OR'd, like isinstance())
-    @setescape(tag="foo")
+    # setescape point tags can be single value or tuple (tuples OR'd, like isinstance())
+    @setescape(tags="foo")
     def foo():
         @immediate
-        @setescape(tag="bar")
+        @setescape(tags="bar")
         def bar():
             @looped
             def s(loop, acc=0, i=0):
diff --git a/unpythonic/ec.py b/unpythonic/ec.py
@@ -24,7 +24,7 @@ def __init__(self, value, tag=None):
         self.value = value
         self.tag = tag
 
-def setescape(tag=None):
+def setescape(tags=None):
     """Decorator. Mark function as exitable by ``raise escape(value)``.
 
     In Lisp terms, this essentially captures the escape continuation (ec)
@@ -34,10 +34,12 @@ def setescape(tag=None):
     to ``return escape(value)``. The trampoline specifically detects ``escape``
     instances, and performs the ``raise``.
 
-    Technically, this is a decorator factory; the optional tag parameter can be
-    used to catch only those escapes with the same tag. ``tag`` can be a single
-    value, or a tuple. Single value means catch that specific tag; tuple means
-    catch any of those tags. Default is None, i.e. catch all.
+    Technically, this is a decorator factory; the optional ``tags`` parameter
+    can be used to catch only those escapes having one of the given tags.
+
+    ``tags`` can be a single value, or a tuple. Single value means catch only
+    that one tag; tuple means catch any of those tags. Default is None,
+    i.e. catch all instances of ``escape``.
 
     Multi-return using escape continuation::
 
@@ -83,12 +85,11 @@ def s(loop, acc=0, i=0):
             return False
         assert f() == 15
     """
-    if tag is None:
-        tags = None
-    elif isinstance(tag, (tuple, list)):  # multiple tags
-        tags = set(tag)
-    else: # single tag
-        tags = set((tag,))
+    if tags is not None:
+        if isinstance(tags, (tuple, list)):  # multiple tags
+            tags = set(tags)
+        else: # single tag
+            tags = set((tags,))
 
     def decorator(f):
         @wraps(f)
diff --git a/unpythonic/tco.py b/unpythonic/tco.py
@@ -599,11 +599,11 @@ def s(loop, acc=0, i=0):
         return False
     assert f() == 15
 
-    # setescape point tag can be single value or tuple (tuples OR'd, like isinstance())
-    @setescape(tag="foo")
+    # setescape point tags can be single value or tuple (tuples OR'd, like isinstance())
+    @setescape(tags="foo")
     def foo():
         @immediate
-        @setescape(tag="bar")
+        @setescape(tags="bar")
         def bar():
             @looped
             def s(loop, acc=0, i=0):
