Use an empty sequence object as a sentinel (#135)

* Use an empty sequence object as a sentinel

* Add is_empty property to Seqs

* Add additional assertions to seq tests

* Small EmptySequence change

Author: chrisrink10

basilisp/compiler.py

@@ -508,7 +508,7 @@ def _do_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
 
 
 def _fn_args_body(ctx: CompilerContext, arg_vec: vec.Vector,  # pylint:disable=too-many-locals
-                  body_exprs: llist.List) -> FunctionDefDetails:
+                  body_exprs: lseq.Seq) -> FunctionDefDetails:
     """Generate the Python AST Nodes for a Lisp function argument vector
     and body expressions. Return a tuple of arg nodes and body AST nodes."""
     st = ctx.symbol_table
@@ -823,7 +823,10 @@ def __f_68(*multi_arity_args):
             kw_defaults=[]),
         body=[_compose_ifs(if_stmts),
               ast.Raise(exc=ast.Call(func=_load_attr('basilisp.lang.runtime.RuntimeException'),
-                                     args=[ast.Str(f"Wrong number of args passed to function: {name}")],
+                                     args=[ast.Str(f"Wrong number of args passed to function: {name}"),
+                                           ast.Call(func=ast.Name(id='len', ctx=ast.Load()),
+                                                    args=[ast.Name(id=_MULTI_ARITY_ARG_NAME, ctx=ast.Load())],
+                                                    keywords=[])],
                                      keywords=[]),
                         cause=None)],
         decorator_list=[],
@@ -1042,7 +1045,7 @@ def let_32(a_33, b_34, c_35):
     # Generate a function to hold the body of the let expression
     letname = genname('let')
     with ctx.new_symbol_table(letname):
-        args, body, vargs = _fn_args_body(ctx, vec.vector(arg_syms.keys()), form[2:])
+        args, body, vargs = _fn_args_body(ctx, vec.vector(arg_syms.keys()), runtime.nthrest(form, 2))
         yield _dependency(_expressionize(body, letname, args=args, vargs=vargs))
 
     # Generate local variable assignments for processing let bindings

basilisp/lang/list.py

@@ -1,8 +1,9 @@
 from pyrsistent import plist, PList
+from pyrsistent._plist import _EMPTY_PLIST
 
 from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
-from basilisp.lang.seq import Seq
+from basilisp.lang.seq import Seq, EMPTY
 from basilisp.lang.util import lrepr
 
 
@@ -43,6 +44,10 @@ def with_meta(self, meta) -> "List":
             meta)
         return list(self._inner, meta=new_meta)
 
+    @property
+    def is_empty(self):
+        return self._inner is _EMPTY_PLIST
+
     @property
     def first(self):
         try:
@@ -51,7 +56,9 @@ def first(self):
             return None
 
     @property
-    def rest(self) -> "List":
+    def rest(self) -> Seq:
+        if self._inner.rest is _EMPTY_PLIST:
+            return EMPTY
         return List(self._inner.rest)
 
     def cons(self, *elems) -> "List":

basilisp/lang/runtime.py

@@ -368,12 +368,12 @@ def rest(o) -> Optional[lseq.Seq]:
     if isinstance(o, lseq.Seq):
         s = o.rest
         if s is None:
-            return lseq.empty()
+            return lseq.EMPTY
         return s
-    s = to_seq(o)
-    if s is None:
-        return lseq.empty()
-    return s.rest
+    n = to_seq(o)
+    if n is None:
+        return lseq.EMPTY
+    return n.rest
 
 
 def nthrest(coll, i: int):
@@ -420,7 +420,7 @@ def cons(o, seq) -> lseq.Seq:
 
 def _seq_or_nil(s: lseq.Seq) -> Optional[lseq.Seq]:
     """Return None if a Seq is empty, the Seq otherwise."""
-    if s.first is None and s.rest == lseq.empty():
+    if s.is_empty:
         return None
     return s
 
@@ -440,7 +440,7 @@ def concat(*seqs) -> lseq.Seq:
     """Concatenate the sequences given by seqs into a single Seq."""
     allseqs = lseq.sequence(itertools.chain(*filter(None, map(to_seq, seqs))))
     if allseqs is None:
-        return lseq.empty()
+        return lseq.EMPTY
     return allseqs
 
 

basilisp/lang/seq.py

@@ -1,8 +1,10 @@
+import itertools
 from abc import ABC, abstractmethod
 from typing import Iterator, Optional, TypeVar, Iterable, Any, Callable
 
 from basilisp.lang.meta import Meta
 from basilisp.lang.util import lrepr
+from basilisp.util import Maybe
 
 T = TypeVar('T')
 
@@ -15,20 +17,28 @@ def __repr__(self):
 
     @property
     @abstractmethod
-    def first(self) -> T:
+    def is_empty(self) -> bool:
         raise NotImplementedError()
 
     @property
     @abstractmethod
-    def rest(self) -> Optional["Seq[T]"]:
+    def first(self) -> Optional[T]:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def rest(self) -> "Seq[T]":
         raise NotImplementedError()
 
     @abstractmethod
     def cons(self, elem):
         raise NotImplementedError()
 
     def __eq__(self, other):
-        for e1, e2 in zip(self, other):
+        sentinel = object()
+        for e1, e2 in itertools.zip_longest(self, other, fillvalue=sentinel):
+            if bool(e1 is sentinel) or bool(e2 is sentinel):
+                return False
             if e1 != e2:
                 return False
         return True
@@ -47,20 +57,50 @@ def seq(self) -> Seq[T]:
         raise NotImplementedError()
 
 
+class _EmptySequence(Seq[T]):
+    def __repr__(self):
+        return '()'
+
+    def __bool__(self):
+        return False
+
+    @property
+    def is_empty(self) -> bool:
+        return True
+
+    @property
+    def first(self) -> Optional[T]:
+        return None
+
+    @property
+    def rest(self) -> Seq[T]:
+        return self
+
+    def cons(self, elem):
+        return Cons(elem, self)
+
+
+EMPTY: Seq = _EmptySequence()
+
+
 class Cons(Seq, Meta):
     __slots__ = ('_first', '_rest', '_meta')
 
     def __init__(self, first=None, seq: Optional[Seq[Any]] = None, meta=None) -> None:
         self._first = first
-        self._rest = seq
+        self._rest = Maybe(seq).or_else_get(EMPTY)
         self._meta = meta
 
     @property
-    def first(self):
+    def is_empty(self) -> bool:
+        return False
+
+    @property
+    def first(self) -> Optional[Any]:
         return self._first
 
     @property
-    def rest(self) -> Optional[Seq[Any]]:
+    def rest(self) -> Seq[Any]:
         return self._rest
 
     def cons(self, elem) -> "Cons":
@@ -92,19 +132,23 @@ def __init__(self, s: Iterator, first: T) -> None:
         self._rest: Optional[Seq] = None  # pylint:disable=assigning-non-slot
 
     @property
-    def first(self) -> T:
+    def is_empty(self) -> bool:
+        return False
+
+    @property
+    def first(self) -> Optional[T]:
         return self._first
 
     @property
-    def rest(self) -> Optional["Seq[T]"]:
+    def rest(self) -> "Seq[T]":
         if self._rest:
             return self._rest
 
         try:
             n = next(self._seq)
             self._rest = _Sequence(self._seq, n)  # pylint:disable=assigning-non-slot
         except StopIteration:
-            self._rest = _EmptySequence()  # pylint:disable=assigning-non-slot
+            self._rest = EMPTY  # pylint:disable=assigning-non-slot
 
         return self._rest
 
@@ -132,31 +176,27 @@ def _realize(self):
     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:
+        if self._seq is None or self._seq.is_empty:
             return True
         return False
 
     @property
-    def first(self) -> T:
+    def first(self) -> Optional[T]:
         if not self._realized:
             self._realize()
         try:
             return self._seq.first  # type: ignore
         except AttributeError:
-            return None  # type: ignore
+            return None
 
     @property
-    def rest(self) -> Optional["Seq[T]"]:
+    def rest(self) -> "Seq[T]":
         if not self._realized:
             self._realize()
         try:
             return self._seq.rest  # type: ignore
         except AttributeError:
-            return empty()
+            return EMPTY
 
     def cons(self, elem):
         return Cons(elem, self)
@@ -176,33 +216,10 @@ def __iter__(self):
             o = o.rest
 
 
-class _EmptySequence(Seq[T]):
-    def __repr__(self):
-        return '()'
-
-    def __bool__(self):
-        return False
-
-    @property
-    def first(self):
-        return None
-
-    @property
-    def rest(self):
-        return _EmptySequence()
-
-    def cons(self, elem):
-        return Cons(elem, self)
-
-
 def sequence(s: Iterable) -> Seq[Any]:
     """Create a Sequence from Iterable s."""
     try:
         i = iter(s)
         return _Sequence(i, next(i))
     except StopIteration:
-        return _EmptySequence()
-
-
-def empty() -> Seq[Any]:
-    return _EmptySequence()
+        return EMPTY

tests/runtime_test.py

@@ -22,11 +22,11 @@ def test_first():
 
 def test_rest():
     assert None is runtime.rest(None)
-    assert llist.l() == runtime.rest(llist.l())
-    assert llist.l() == runtime.rest(llist.l(1))
+    assert lseq.EMPTY is runtime.rest(llist.l())
+    assert lseq.EMPTY is runtime.rest(llist.l(1))
     assert llist.l(2, 3) == runtime.rest(llist.l(1, 2, 3))
-    assert llist.l() == runtime.rest(vec.v(1).seq())
-    assert llist.l() == runtime.rest(vec.v(1))
+    assert lseq.EMPTY is runtime.rest(vec.v(1).seq())
+    assert lseq.EMPTY is runtime.rest(vec.v(1))
     assert llist.l(2, 3) == runtime.rest(vec.v(1, 2, 3))
 
 
@@ -93,6 +93,8 @@ def test_to_seq():
     assert None is runtime.to_seq(lset.Set.empty())
     assert None is runtime.to_seq("")
 
+    assert None is not runtime.to_seq(llist.l(None))
+    assert None is not runtime.to_seq(llist.l(None, None, None))
     assert None is not runtime.to_seq(llist.l(1))
     assert None is not runtime.to_seq(vec.v(1))
     assert None is not runtime.to_seq(lmap.map({"a": 1}))
@@ -117,10 +119,10 @@ def test_to_seq():
 
 def test_concat():
     s1 = runtime.concat()
-    assert llist.l() == s1
+    assert lseq.EMPTY is s1
 
     s1 = runtime.concat(llist.List.empty(), llist.List.empty())
-    assert llist.l() == s1
+    assert lseq.EMPTY == s1
 
     s1 = runtime.concat(llist.List.empty(), llist.l(1, 2, 3))
     assert s1 == llist.l(1, 2, 3)
@@ -132,7 +134,9 @@ def test_concat():
 def test_apply():
     assert vec.v() == runtime.apply(vec.v, [[]])
     assert vec.v(1, 2, 3) == runtime.apply(vec.v, [[1, 2, 3]])
+    assert vec.v(None, None, None) == runtime.apply(vec.v, [[None, None, None]])
     assert vec.v(vec.v(1, 2, 3), 4, 5, 6) == runtime.apply(vec.v, [vec.v(1, 2, 3), [4, 5, 6]])
+    assert vec.v(vec.v(1, 2, 3), None, None, None) == runtime.apply(vec.v, [vec.v(1, 2, 3), [None, None, None]])
 
 
 def test_nth():