Fix RecursionError with concat and LazySeqs (#588)

* Fix RecursionError with concat and LazySeqs

* Fix RecursionError in concat of LazySeq

* LazySeq with_meta fix

* Changelog

* Fix it

Author: chrisrink10

CHANGELOG.md

@@ -12,9 +12,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Added `*basilisp-version*` and `*python-version*` Vars to `basilisp.core` (#584)
  * Added support for function decorators to `defn` (#585)
  * Added the current Python version (`:lpy36`, `:lpy37`, etc.) as a default reader feature for reader conditionals (#585)
+ * Added `lazy-cat` function for lazily concatenating sequences (#588)
+
+### Changed
+ * Moved `basilisp.lang.runtime.to_seq` to `basilisp.lang.seq` so it can be used within that module and by `basilisp.lang.runtime` without circular import (#588)
 
 ### Fixed
  * Fixed a bug where `def` forms did not permit recursive references to the `def`'ed Vars (#578)
+ * Fixed a bug where `concat` could cause a `RecursionEror` if used on a `LazySeq` instance which itself calls `concat` (#588)
 
 ## [v0.1.dev14] - 2020-06-18
 ### Added

src/basilisp/core.lpy

@@ -2172,6 +2172,12 @@
   (list 'basilisp.lang.seq/LazySeq
         (concat '(fn* []) body)))
 
+(defmacro lazy-cat
+  "Return a lazy sequence of the concatenation of `colls`. None of the input
+  collections will be evaluated until it is needed."
+  [& colls]
+  `(concat ~@(map (fn [coll] `(lazy-seq ~coll)) colls)))
+
 (defn dorun
   "Force a lazy sequence be fully realized. Returns nil.
 

src/basilisp/lang/runtime.py

@@ -50,7 +50,6 @@
     IPersistentSet,
     IPersistentVector,
     ISeq,
-    ISeqable,
     ITransientSet,
 )
 from basilisp.lang.reference import ReferenceBase
@@ -939,37 +938,12 @@ def cons(o, seq) -> ISeq:
     return _cons(seq, o)
 
 
-def _seq_or_nil(s: ISeq) -> Optional[ISeq]:
-    """Return None if a ISeq is empty, the ISeq otherwise."""
-    if s.is_empty:
-        return None
-    return s
-
-
-@functools.singledispatch
-def to_seq(o) -> Optional[ISeq]:
-    """Coerce the argument o to a ISeq. If o is None, return None."""
-    return _seq_or_nil(lseq.sequence(o))
-
-
-@to_seq.register(type(None))
-def _to_seq_none(_) -> None:
-    return None
-
-
-@to_seq.register(ISeq)
-def _to_seq_iseq(o: ISeq) -> Optional[ISeq]:
-    return _seq_or_nil(o)
-
-
-@to_seq.register(ISeqable)
-def _to_seq_iseqable(o: ISeqable) -> Optional[ISeq]:
-    return _seq_or_nil(o.seq())
+to_seq = lseq.to_seq
 
 
 def concat(*seqs) -> ISeq:
     """Concatenate the sequences given by seqs into a single ISeq."""
-    allseqs = lseq.sequence(itertools.chain(*filter(None, map(to_seq, seqs))))
+    allseqs = lseq.sequence(itertools.chain.from_iterable(filter(None, seqs)))
     if allseqs is None:
         return lseq.EMPTY
     return allseqs

src/basilisp/lang/seq.py

@@ -1,6 +1,13 @@
+import functools
 from typing import Any, Callable, Iterable, Iterator, Optional, TypeVar
 
-from basilisp.lang.interfaces import IPersistentMap, ISeq, ISequential, IWithMeta
+from basilisp.lang.interfaces import (
+    IPersistentMap,
+    ISeq,
+    ISeqable,
+    ISequential,
+    IWithMeta,
+)
 from basilisp.util import Maybe
 
 T = TypeVar("T")
@@ -128,60 +135,57 @@ def cons(self, elem):
         return Cons(elem, self)
 
 
+LazySeqGenerator = Callable[[], Optional[ISeq[T]]]
+
+
 class LazySeq(IWithMeta, ISequential, ISeq[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", "_meta")
+    __slots__ = ("_gen", "_seq", "_meta")
 
     # pylint:disable=assigning-non-slot
     def __init__(
         self,
-        gen: Callable[[], Optional[ISeq[T]]],
+        gen: Optional[LazySeqGenerator],
+        seq: Optional[ISeq[T]] = None,
         *,
         meta: Optional[IPersistentMap] = None,
     ) -> None:
-        self._gen = gen
-        self._realized = False
-        self._seq: Optional[ISeq[T]] = None
+        self._gen: Optional[LazySeqGenerator] = gen
+        self._seq: Optional[ISeq[T]] = seq
         self._meta = meta
 
     @property
     def meta(self) -> Optional[IPersistentMap]:
         return self._meta
 
     def with_meta(self, meta: Optional[IPersistentMap]) -> "LazySeq[T]":
-        return LazySeq(self._gen, meta=meta)
+        return LazySeq(self._gen, seq=self._seq, meta=meta)
 
     # pylint:disable=assigning-non-slot
     def _realize(self):
-        if not self._realized:
-            self._seq = self._gen()
-            self._realized = True
+        if self._gen is not None:
+            self._seq = to_seq(self._gen())
+            self._gen = None
 
     @property
     def is_empty(self) -> bool:
-        if not self._realized:
-            self._realize()
-            return self.is_empty
-        if self._seq is None or self._seq.is_empty:
-            return True
-        return False
+        self._realize()
+        return self._seq is None
 
     @property
     def first(self) -> Optional[T]:
-        if not self._realized:
-            self._realize()
+        self._realize()
         try:
             return self._seq.first  # type: ignore
         except AttributeError:
             return None
 
     @property
     def rest(self) -> "ISeq[T]":
-        if not self._realized:
-            self._realize()
+        self._realize()
         try:
             return self._seq.rest  # type: ignore
         except AttributeError:
@@ -192,7 +196,7 @@ def cons(self, elem):
 
     @property
     def is_realized(self):
-        return self._realized
+        return self._gen is None
 
 
 def sequence(s: Iterable) -> ISeq[Any]:
@@ -202,3 +206,31 @@ def sequence(s: Iterable) -> ISeq[Any]:
         return _Sequence(i, next(i))
     except StopIteration:
         return EMPTY
+
+
+def _seq_or_nil(s: ISeq) -> Optional[ISeq]:
+    """Return None if a ISeq is empty, the ISeq otherwise."""
+    if s.is_empty:
+        return None
+    return s
+
+
+@functools.singledispatch
+def to_seq(o) -> Optional[ISeq]:
+    """Coerce the argument o to a ISeq. If o is None, return None."""
+    return _seq_or_nil(sequence(o))
+
+
+@to_seq.register(type(None))
+def _to_seq_none(_) -> None:
+    return None
+
+
+@to_seq.register(ISeq)
+def _to_seq_iseq(o: ISeq) -> Optional[ISeq]:
+    return _seq_or_nil(o)
+
+
+@to_seq.register(ISeqable)
+def _to_seq_iseqable(o: ISeqable) -> Optional[ISeq]:
+    return _seq_or_nil(o.seq())

tests/basilisp/test_core_macros.lpy

@@ -349,7 +349,25 @@
                #{1 3 5} :>> dec
                :a)))))
 
+(deftest lazy-cat-test
+  (is (= '(1 2 3 4 5 6) (lazy-cat [1 2 3] [4 5 6])))
+
+  (testing "laziness"
+    (let [a (atom nil)]
+      (is (= '(1 2 3 4 5)
+             (take 5
+                   (lazy-cat [1 2 3 4 5 6]
+                             (map #(reset! a %) [7 8 9 0])))))
+      (is (nil? @a))
+      (is (= [1 2 3 4 5 6 7 8 9 0]
+             (lazy-cat [1 2 3 4 5]
+                       (map #(reset! a %) [6 7 8 9 0]))))
+      (is (zero? @a)))))
+
 (deftest for-test
+  (testing "no recursion error"
+    (is (= 10000 (count (for [x (range 100), y (range 100)] [x y])))))
+
   (testing "basic for comprehensions"
     (is (= [1 2 3 4] (for [x [1 2 3 4]] x)))