Lazy sequences and tests (#118)

Author: chrisrink10

basilisp/lang/seq.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Iterator, Optional, TypeVar, Iterable, Any
+from typing import Iterator, Optional, TypeVar, Iterable, Any, Callable
 
 from basilisp.lang.meta import Meta
 from basilisp.lang.util import lrepr
@@ -112,6 +112,70 @@ def cons(self, elem):
         return Cons(elem, self)
 
 
+class LazySeq(Seq[T]):
+    """LazySeqs are wrappers for delaying sequence computation. Create a LazySeq
+    with a function that can either return None or a Seq. If a Seq is returned,
+    the LazySeq is a proxy to that Seq."""
+    __slots__ = ('_gen', '_realized', '_seq')
+
+    def __init__(self, gen: Callable[[], Optional[Seq]]) -> None:
+        self._gen = gen  # pylint:disable=assigning-non-slot
+        self._realized = False  # pylint:disable=assigning-non-slot
+        self._seq: Optional[Seq] = None  # pylint:disable=assigning-non-slot
+
+    def _realize(self):
+        if not self._realized:
+            self._seq = self._gen()  # pylint:disable=assigning-non-slot
+            self._realized = True  # pylint:disable=assigning-non-slot
+
+    @property
+    def is_empty(self) -> bool:
+        if not self._realized:
+            return False
+        if self._seq is None:
+            return True
+        if self._seq.first is None and self._seq.rest == empty():
+            return True
+        if isinstance(self._seq, LazySeq) and self._seq.is_empty:
+            return True
+        return False
+
+    @property
+    def first(self) -> T:
+        if not self._realized:
+            self._realize()
+        try:
+            return self._seq.first  # type: ignore
+        except AttributeError:
+            return None  # type: ignore
+
+    @property
+    def rest(self) -> Optional["Seq[T]"]:
+        if not self._realized:
+            self._realize()
+        try:
+            return self._seq.rest  # type: ignore
+        except AttributeError:
+            return empty()
+
+    def cons(self, elem):
+        return Cons(elem, self)
+
+    @property
+    def realized(self):
+        return self._realized
+
+    def __iter__(self):
+        o = self
+        while o:
+            first = o.first
+            if isinstance(o, LazySeq):
+                if o.is_empty:
+                    return
+            yield first
+            o = o.rest
+
+
 class _EmptySequence(Seq[T]):
     def __repr__(self):
         return '()'

tests/seq_test.py

@@ -8,6 +8,61 @@ def test_to_sequence():
     assert llist.l(1, 2, 3) == lseq.sequence([1, 2, 3])
 
 
+def test_lazy_sequence():
+    s = lseq.LazySeq(lambda: None)
+    assert not s.is_empty, "LazySeq has not been realized yet"
+    assert None is s.first
+    assert lseq.empty() == s.rest
+    assert s.realized
+    assert s.is_empty, "LazySeq has been realized and is empty"
+
+    s = lseq.LazySeq(lambda: lseq.empty())
+    assert not s.is_empty, "LazySeq has not been realized yet"
+    assert None is s.first
+    assert lseq.empty() == s.rest
+    assert s.realized
+    assert s.is_empty, "LazySeq has been realized and is empty"
+
+    s = lseq.LazySeq(lambda: lseq.sequence([1]))
+    assert not s.is_empty, "LazySeq has not been realized yet"
+    assert 1 == s.first
+    assert lseq.empty() == s.rest
+    assert s.realized
+    assert not s.is_empty, "LazySeq has been realized and is not empty"
+
+    def lazy_seq():
+        def inner_seq():
+            def inner_inner_seq():
+                return lseq.sequence([3])
+
+            return lseq.LazySeq(inner_inner_seq).cons(2)
+
+        return lseq.LazySeq(inner_seq).cons(1)
+
+    s = lseq.LazySeq(lazy_seq)
+    assert not s.is_empty, "LazySeq has not been realized yet"
+    assert 1 == s.first
+    assert isinstance(s.rest, lseq.LazySeq)
+    assert s.realized
+    assert not s.is_empty, "LazySeq has been realized and is not empty"
+
+    r = s.rest
+    assert not r.is_empty, "LazySeq has not been realized yet"
+    assert 2 == r.first
+    assert isinstance(r.rest, lseq.LazySeq)
+    assert r.realized
+    assert not r.is_empty, "LazySeq has been realized and is not empty"
+
+    t = r.rest
+    assert not t.is_empty, "LazySeq has not been realized yet"
+    assert 3 == t.first
+    assert lseq.empty() == t.rest
+    assert t.realized
+    assert not t.is_empty, "LazySeq has been realized and is not empty"
+
+    assert [1, 2, 3] == [e for e in s]
+
+
 def test_empty_sequence():
     empty = lseq.sequence([])
     assert None is empty.first