CHANGE: fup, view, islice are now regular functions, not macros

Technologicat · Technologicat · commit 4c0c5d41eb2e · 2019-02-28T03:01:52.000+02:00
diff --git a/unpythonic/__init__.py b/unpythonic/__init__.py
@@ -32,6 +32,7 @@
 from .mathseq import *
 from .misc import *
 from .seq import *
+from .slicing import *
 from .tco import *
 
 # HACK: break dependency loop
diff --git a/unpythonic/slicing.py b/unpythonic/slicing.py
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+"""Operations on sequences, with native slice syntax. Syntactic sugar, pure Python."""
+
+from itertools import islice as islicef
+from unpythonic import SequenceView, fupdate
+
+view = SequenceView
+view.__doc__ = """Alias for ``unpythonic.collections.SequenceView``.
+
+Usage::
+
+    view(seq)[slicestx]
+"""
+
+def islice(iterable):
+    """Use itertools.islice with slice syntax.
+
+    Usage::
+
+        islice(iterable)[idx_or_slice]
+
+    The slicing variant calls ``itertools.islice`` with the corresponding
+    slicing parameters.
+
+    As a convenience feature: a single index is interpreted as a length-1 islice
+    starting at that index. The slice is then immediately evaluated and the item
+    is returned.
+
+    Examples::
+
+        from unpythonic import primes, s
+
+        p = primes()
+        assert tuple(islice(p)[10:15]) == (31, 37, 41, 43, 47)
+
+        assert tuple(islice(primes())[10:15]) == (31, 37, 41, 43, 47)
+
+        p = primes()
+        assert islice(p)[10] == 31
+
+        odds = islice(s(1, 2, ...))[::2]
+        assert tuple(islice(odds)[:5]) == (1, 3, 5, 7, 9)
+        assert tuple(islice(odds)[:5]) == (11, 13, 15, 17, 19)  # five more
+
+    **CAUTION**: Keep in mind ``itertools.islice`` does not support negative
+    indexing for any of ``start``, ``stop`` or ``step``, and that the slicing
+    process consumes elements from the iterable.
+    """
+    # manually curry to take indices later, but expect them in subscript syntax to support slicing
+    class islice1:
+        """Subscript me to perform the slicing."""
+        def __getitem__(self, k):
+            if isinstance(k, tuple):
+                raise TypeError("multidimensional indexing not supported, got {}".format(k))
+            if isinstance(k, slice):
+                return islicef(iterable, k.start, k.stop, k.step)
+            return tuple(islicef(iterable, k, k + 1))[0]
+    return islice1()
+
+def fup(seq):
+    """Functionally update a sequence.
+
+    Usage::
+
+        fup(seq)[idx_or_slice] << values
+
+    For when you want to be more functional than Python allows. Example::
+
+        from itertools import repeat
+
+        lst = (1, 2, 3, 4, 5)
+        assert fup(lst)[3] << 42 == (1, 2, 3, 42, 5)
+        assert fup(lst)[0::2] << tuple(repeat(10, 3)) == (10, 2, 10, 4, 10)
+
+    Limitations:
+
+      - Currently only one update specification is supported in a single ``fup()``.
+        If you need more, use ``fupdate`` directly.
+
+    Named after the sound a sequence makes when it is hit by a functional update.
+    """
+    # two-phase manual curry, first expect a subscript, then an lshift.
+    class fup1:
+        """Subscript me to specify index or slice where to fupdate."""
+        def __getitem__(self, k):
+            if isinstance(k, tuple):
+                raise TypeError("multidimensional indexing not supported, got {}".format(k))
+            class fup2:
+                """Left-shift me with values to perform the fupdate."""
+                def __lshift__(self, v):
+                    return fupdate(seq, k, v)
+            return fup2()
+    return fup1()
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -24,7 +24,6 @@
 from .letsyntax import let_syntax_expr, let_syntax_block, block, expr
 from .nb import nb as _nb
 from .prefix import prefix as _prefix
-from .slicing import fup as _fup, view as _view, islice as _islice
 from .tailtools import autoreturn as _autoreturn, tco as _tco, \
                        continuations as _continuations, call_cc
 
@@ -790,94 +789,6 @@ def quicklambda(tree, **kw):
 
 # -----------------------------------------------------------------------------
 
-@macros.expr
-def fup(tree, **kw):
-    """[syntax, expr] Functionally update a sequence.
-
-    For when you want to be more functional than Python allows.
-
-    Example::
-
-        from itertools import repeat
-
-        lst = (1, 2, 3, 4, 5)
-        assert fup[lst[3] << 42] == (1, 2, 3, 42, 5)
-        assert fup[lst[0::2] << tuple(repeat(10, 3))] == (10, 2, 10, 4, 10)
-
-    The transformation is::
-
-        fup[seq[idx] << value] --> fupdate(seq, idx, value)
-        fup[seq[slicestx] << iterable] --> fupdate(seq, slice(...), iterable)
-
-    Limitations:
-
-      - Currently only one update specification is supported in a single ``fup[]``.
-
-    Named after the sound a sequence makes when it is hit by a functional update.
-    """
-    return _fup(tree)
-
-@macros.expr
-def view(tree, **kw):
-    """[syntax, expr] Writable view into a sequence.
-
-    For when you want to be more imperative than Python allows.
-
-    Examples::
-
-        lst = [1, 2, 3, 4, 5]
-        v = view[lst[2:4]]
-        v[:] = [10, 20]
-        assert lst == [1, 2, 10, 20, 5]
-
-        lst = [1, 2, 3, 4, 5]
-        v = view[lst]
-        v[2:4] = [10, 20]
-        assert lst == [1, 2, 10, 20, 5]
-
-    The transformation is::
-
-        view[seq] --> SequenceView(seq)
-        view[seq[slicestx]] --> SequenceView(seq, slice(...))
-    """
-    return _view(tree)
-
-@macros.expr
-def islice(tree, **kw):
-    """[syntax, expr] Use itertools.islice with slice syntax.
-
-    An ``islice[]`` slicing expression transforms into a call to
-    ``itertools.islice`` with the corresponding slicing parameters.
-
-    As a convenience feature: inside an ``islice[]`` expression, a single index
-    is interpreted as a length-1 islice starting at that index. The slice is then
-    immediately evaluated and the item is returned.
-
-    Examples::
-
-        from unpythonic.syntax import macros, islice
-        from unpythonic import primes, s
-
-        p = primes()
-        assert tuple(islice[p[10:15]]) == (31, 37, 41, 43, 47)
-
-        assert tuple(islice[primes()[10:15]]) == (31, 37, 41, 43, 47)
-
-        p = primes()
-        assert islice[p[10]] == 31
-
-        odds = islice[s(1, 2, ...)[::2]]
-        assert tuple(islice[odds[:5]]) == (1, 3, 5, 7, 9)
-        assert tuple(islice[odds[:5]]) == (11, 13, 15, 17, 19)  # five more
-
-    **CAUTION**: Keep in mind ``itertools.islice`` does not support negative
-    indexing for any of ``start``, ``stop`` or ``step``, and that the slicing
-    process consumes elements from the iterable.
-    """
-    return _islice(tree)
-
-# -----------------------------------------------------------------------------
-
 @macros.block
 def autoreturn(tree, **kw):
     """[syntax, block] Implicit "return" in tail position, like in Lisps.
diff --git a/unpythonic/syntax/slicing.py b/unpythonic/syntax/slicing.py
diff --git a/unpythonic/syntax/test/test_slicing.py b/unpythonic/syntax/test/test_slicing.py
diff --git a/unpythonic/test/test_slicing.py b/unpythonic/test/test_slicing.py
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""Operations on sequences, with native slice syntax. Syntactic sugar, pure Python."""
+
+from itertools import repeat
+
+from ..slicing import fup, view, islice
+from ..mathseq import primes, s
+
+def test():
+    # functional update for sequences
+    # (when you want to be more functional than Python allows)
+    lst = (1, 2, 3, 4, 5)
+    assert fup(lst)[3] << 42 == (1, 2, 3, 42, 5)
+    assert fup(lst)[0::2] << tuple(repeat(10, 3)) == (10, 2, 10, 4, 10)
+    assert fup(lst)[1::2] << tuple(repeat(10, 3)) == (1, 10, 3, 10, 5)
+    assert fup(lst)[::2] << tuple(repeat(10, 3)) == (10, 2, 10, 4, 10)
+    assert fup(lst)[::-1] << tuple(range(5)) == (4, 3, 2, 1, 0)
+    assert lst == (1, 2, 3, 4, 5)
+
+    # writable view for sequences
+    # (when you want to be more imperative than Python allows)
+    lst = [1, 2, 3, 4, 5]
+    v = view(lst)[2:4]
+    v[:] = [10, 20]
+    assert lst == [1, 2, 10, 20, 5]
+
+    lst = [1, 2, 3, 4, 5]
+    v = view(lst)
+    v[2:4] = [10, 20]
+    assert lst == [1, 2, 10, 20, 5]
+
+    # slice syntax wrapper for itertools.islice
+    p = primes()
+    assert tuple(islice(p)[10:15]) == (31, 37, 41, 43, 47)
+
+    assert tuple(islice(primes())[10:15]) == (31, 37, 41, 43, 47)
+
+    p = primes()
+    assert islice(p)[10] == 31
+
+    odds = islice(s(1, 2, ...))[::2]
+    assert tuple(islice(odds)[:5]) == (1, 3, 5, 7, 9)
+    assert tuple(islice(odds)[:5]) == (11, 13, 15, 17, 19)  # five more
+
+    print("All tests PASSED")
+
+if __name__ == '__main__':
+    test()
