Add a Persistent Queue data type (#606)

 * Adds a Persistent Queue data structure, which `conj`s at the tail but `pop`s from the head.
 * Convert all builtin collection types to use a single `EMPTY` constant for `empty()`, which should hopefully reduce the amount of time spent allocating new empty collections for such calls.

Author: chrisrink10

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Added default reader features for matching Python version ranges (`:lpy36+`, `:lpy38-`, etc.) (#593)
  * Added `lazy-cat` function for lazily concatenating sequences (#588)
  * Added support for writing EDN strings from `basilisp.edn` (#600)
+ * Added a persistent queue data type (#606)
 
 ### 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)

src/basilisp/lang/compiler/analyzer.py

@@ -35,6 +35,7 @@
 from basilisp.lang import keyword as kw
 from basilisp.lang import list as llist
 from basilisp.lang import map as lmap
+from basilisp.lang import queue as lqueue
 from basilisp.lang import reader as reader
 from basilisp.lang import runtime as runtime
 from basilisp.lang import set as lset
@@ -114,12 +115,9 @@
     PyList,
     PySet,
     PyTuple,
-    Quote,
-    Recur,
-    Reify,
-    Require,
-    RequireAlias,
 )
+from basilisp.lang.compiler.nodes import Queue as QueueNode
+from basilisp.lang.compiler.nodes import Quote, Recur, Reify, Require, RequireAlias
 from basilisp.lang.compiler.nodes import Set as SetNode
 from basilisp.lang.compiler.nodes import SetBang, SpecialFormNode, Throw, Try, VarRef
 from basilisp.lang.compiler.nodes import Vector as VectorNode
@@ -3339,6 +3337,25 @@ def _map_node_or_quoted(
     return _map_node(form, ctx)
 
 
+@_with_meta
+def _queue_node(form: lqueue.PersistentQueue, ctx: AnalyzerContext) -> QueueNode:
+    return QueueNode(
+        form=form,
+        items=vec.vector(map(lambda form: _analyze_form(form, ctx), form)),
+        env=ctx.get_node_env(pos=ctx.syntax_position),
+    )
+
+
+@_analyze_form.register(lqueue.PersistentQueue)
+@_with_loc
+def _queue_node_or_quoted(
+    form: lqueue.PersistentQueue, ctx: AnalyzerContext
+) -> Union[Const, QueueNode]:
+    if ctx.is_quoted:
+        return _const_node(form, ctx)
+    return _queue_node(form, ctx)
+
+
 @_with_meta
 def _set_node(form: lset.PersistentSet, ctx: AnalyzerContext) -> SetNode:
     return SetNode(
@@ -3395,6 +3412,7 @@ def _const_node_type(_: Any) -> ConstType:
     list: ConstType.PY_LIST,
     llist.PersistentList: ConstType.SEQ,
     lmap.PersistentMap: ConstType.MAP,
+    lqueue.PersistentQueue: ConstType.QUEUE,
     lset.PersistentSet: ConstType.SET,
     IRecord: ConstType.RECORD,
     ISeq: ConstType.SEQ,
@@ -3438,6 +3456,7 @@ def _const_node(form: ReaderForm, ctx: AnalyzerContext) -> Const:
                     vec.PersistentVector,
                     llist.PersistentList,
                     lmap.PersistentMap,
+                    lqueue.PersistentQueue,
                     lset.PersistentSet,
                     ISeq,
                 ),

src/basilisp/lang/compiler/generator.py

@@ -31,6 +31,7 @@
 from basilisp.lang import keyword as kw
 from basilisp.lang import list as llist
 from basilisp.lang import map as lmap
+from basilisp.lang import queue as lqueue
 from basilisp.lang import reader as reader
 from basilisp.lang import runtime as runtime
 from basilisp.lang import set as lset
@@ -86,12 +87,9 @@
     PyList,
     PySet,
     PyTuple,
-    Quote,
-    ReaderLispForm,
-    Recur,
-    Reify,
-    Require,
 )
+from basilisp.lang.compiler.nodes import Queue as QueueNode
+from basilisp.lang.compiler.nodes import Quote, ReaderLispForm, Recur, Reify, Require
 from basilisp.lang.compiler.nodes import Set as SetNode
 from basilisp.lang.compiler.nodes import SetBang, Throw, Try, VarRef
 from basilisp.lang.compiler.nodes import Vector as VectorNode
@@ -591,6 +589,7 @@ def _var_ns_as_python_sym(name: str) -> str:
 _MAP_ALIAS = genname("lmap")
 _MULTIFN_ALIAS = genname("multifn")
 _PROMISE_ALIAS = genname("promise")
+_QUEUE_ALIAS = genname("queue")
 _READER_ALIAS = genname("reader")
 _RUNTIME_ALIAS = genname("runtime")
 _SEQ_ALIAS = genname("seq")
@@ -613,6 +612,7 @@ def _var_ns_as_python_sym(name: str) -> str:
     "basilisp.lang.map": _MAP_ALIAS,
     "basilisp.lang.multifn": _MULTIFN_ALIAS,
     "basilisp.lang.promise": _PROMISE_ALIAS,
+    "basilisp.lang.queue": _QUEUE_ALIAS,
     "basilisp.lang.reader": _READER_ALIAS,
     "basilisp.lang.runtime": _RUNTIME_ALIAS,
     "basilisp.lang.seq": _SEQ_ALIAS,
@@ -631,6 +631,7 @@ def _var_ns_as_python_sym(name: str) -> str:
 _NEW_KW_FN_NAME = _load_attr(f"{_KW_ALIAS}.keyword_from_hash")
 _NEW_LIST_FN_NAME = _load_attr(f"{_LIST_ALIAS}.list")
 _EMPTY_LIST_FN_NAME = _load_attr(f"{_LIST_ALIAS}.List.empty")
+_NEW_QUEUE_FN_NAME = _load_attr(f"{_QUEUE_ALIAS}.queue")
 _NEW_MAP_FN_NAME = _load_attr(f"{_MAP_ALIAS}.map")
 _NEW_REGEX_FN_NAME = _load_attr(f"{_UTIL_ALIAS}.regex_from_str")
 _NEW_SET_FN_NAME = _load_attr(f"{_SET_ALIAS}.set")
@@ -2975,6 +2976,35 @@ def _map_to_py_ast(
     )
 
 
+@_with_ast_loc
+def _queue_to_py_ast(
+    ctx: GeneratorContext, node: QueueNode, meta_node: Optional[MetaNode] = None
+) -> GeneratedPyAST:
+    assert node.op == NodeOp.QUEUE
+
+    meta_ast: Optional[GeneratedPyAST]
+    if meta_node is not None:
+        meta_ast = gen_py_ast(ctx, meta_node)
+    else:
+        meta_ast = None
+
+    elem_deps, elems = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.items))
+    return GeneratedPyAST(
+        node=ast.Call(
+            func=_NEW_QUEUE_FN_NAME,
+            args=[ast.List(list(elems), ast.Load())],
+            keywords=Maybe(meta_ast)
+            .map(lambda p: [ast.keyword(arg="meta", value=p.node)])
+            .or_else_get([]),
+        ),
+        dependencies=list(
+            chain(
+                Maybe(meta_ast).map(lambda p: p.dependencies).or_else_get([]), elem_deps
+            )
+        ),
+    )
+
+
 @_with_ast_loc
 def _set_to_py_ast(
     ctx: GeneratorContext, node: SetNode, meta_node: Optional[MetaNode] = None
@@ -3087,6 +3117,7 @@ def _py_tuple_to_py_ast(ctx: GeneratorContext, node: PyTuple) -> GeneratedPyAST:
 _WITH_META_EXPR_HANDLER = {
     NodeOp.FN: _fn_to_py_ast,
     NodeOp.MAP: _map_to_py_ast,
+    NodeOp.QUEUE: _queue_to_py_ast,
     NodeOp.REIFY: _reify_to_py_ast,
     NodeOp.SET: _set_to_py_ast,
     NodeOp.VECTOR: _vec_to_py_ast,
@@ -3289,6 +3320,24 @@ def _const_map_to_py_ast(
     )
 
 
+@_const_val_to_py_ast.register(lqueue.PersistentQueue)
+def _const_queue_to_py_ast(
+    form: lqueue.PersistentQueue, ctx: GeneratorContext
+) -> GeneratedPyAST:
+    elem_deps, elems = _chain_py_ast(*_collection_literal_to_py_ast(ctx, form))
+    meta = _const_meta_kwargs_ast(ctx, form)
+    return GeneratedPyAST(
+        node=ast.Call(
+            func=_NEW_QUEUE_FN_NAME,
+            args=[ast.List(list(elems), ast.Load())],
+            keywords=Maybe(meta).map(lambda p: [p.node]).or_else_get([]),
+        ),
+        dependencies=list(
+            chain(elem_deps, Maybe(meta).map(lambda p: p.dependencies).or_else_get([]))
+        ),
+    )
+
+
 @_const_val_to_py_ast.register(lset.PersistentSet)
 def _const_set_to_py_ast(
     form: lset.PersistentSet, ctx: GeneratorContext
@@ -3447,6 +3496,7 @@ def _const_node_to_py_ast(ctx: GeneratorContext, lisp_ast: Const) -> GeneratedPy
     NodeOp.PY_LIST: _py_list_to_py_ast,
     NodeOp.PY_SET: _py_set_to_py_ast,
     NodeOp.PY_TUPLE: _py_tuple_to_py_ast,
+    NodeOp.QUEUE: _queue_to_py_ast,
     NodeOp.QUOTE: _quote_to_py_ast,
     NodeOp.RECUR: _recur_to_py_ast,  # type: ignore
     NodeOp.REIFY: _reify_to_py_ast,

src/basilisp/lang/compiler/nodes.py

@@ -17,6 +17,7 @@
 
 from basilisp.lang import keyword as kw
 from basilisp.lang import map as lmap
+from basilisp.lang import queue as lqueue
 from basilisp.lang import set as lset
 from basilisp.lang import symbol as sym
 from basilisp.lang import vector as vec
@@ -90,6 +91,7 @@ class NodeOp(Enum):
     PY_LIST = kw.keyword("py-list")
     PY_SET = kw.keyword("py-set")
     PY_TUPLE = kw.keyword("py-tuple")
+    QUEUE = kw.keyword("queue")
     QUOTE = kw.keyword("quote")
     RECUR = kw.keyword("recur")
     REIFY = kw.keyword("reify")
@@ -259,6 +261,7 @@ class NodeSyntacticPosition(Enum):
 class ConstType(Enum):
     NIL = kw.Keyword("nil")
     MAP = kw.keyword("map")
+    QUEUE = kw.keyword("queue")
     SET = kw.keyword("set")
     VECTOR = kw.keyword("vector")
     BOOL = kw.keyword("bool")
@@ -774,6 +777,17 @@ class PyTuple(Node[tuple]):
     raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty()
 
 
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class Queue(Node[lqueue.PersistentQueue]):
+    form: lqueue.PersistentQueue
+    items: Iterable[Node]
+    env: NodeEnv
+    children: Sequence[kw.Keyword] = vec.v(ITEMS)
+    op: NodeOp = NodeOp.QUEUE
+    top_level: bool = False
+    raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty()
+
+
 @attr.s(auto_attribs=True, frozen=True, slots=True)
 class Quote(Node[SpecialForm]):
     form: SpecialForm
@@ -918,7 +932,7 @@ class Vector(Node[IPersistentVector]):
 class WithMeta(Node[LispForm]):
     form: LispForm
     meta: Union[Const, Map]
-    expr: Union[Fn, Map, Set, Vector]
+    expr: Union[Fn, Map, Queue, Set, Vector]
     env: NodeEnv
     children: Sequence[kw.Keyword] = vec.v(META, EXPR)
     op: NodeOp = NodeOp.WITH_META

src/basilisp/lang/list.py

@@ -5,7 +5,7 @@
 
 from basilisp.lang.interfaces import IPersistentList, IPersistentMap, ISeq, IWithMeta
 from basilisp.lang.obj import seq_lrepr as _seq_lrepr
-from basilisp.lang.seq import EMPTY
+from basilisp.lang.seq import EMPTY as _EMPTY_SEQ
 
 T = TypeVar("T")
 
@@ -60,7 +60,7 @@ def first(self):
     @property
     def rest(self) -> ISeq[T]:
         if self._inner.rest is _EMPTY_PLIST:
-            return EMPTY
+            return _EMPTY_SEQ
         return PersistentList(self._inner.rest)
 
     def cons(self, *elems: T) -> "PersistentList[T]":
@@ -70,8 +70,8 @@ def cons(self, *elems: T) -> "PersistentList[T]":
         return PersistentList(l)
 
     @staticmethod
-    def empty(meta=None) -> "PersistentList":  # pylint:disable=arguments-differ
-        return l(meta=meta)
+    def empty() -> "PersistentList":
+        return EMPTY
 
     def peek(self):
         return self.first
@@ -82,6 +82,9 @@ def pop(self) -> "PersistentList[T]":
         return cast(PersistentList, self.rest)
 
 
+EMPTY: PersistentList = PersistentList(plist())
+
+
 def list(members, meta=None) -> PersistentList:  # pylint:disable=redefined-builtin
     """Creates a new list."""
     return PersistentList(  # pylint: disable=abstract-class-instantiated

src/basilisp/lang/map.py

@@ -244,7 +244,7 @@ def cons(  # type: ignore[override]
 
     @staticmethod
     def empty() -> "PersistentMap":
-        return m()
+        return EMPTY
 
     def seq(self) -> ISeq[IMapEntry[K, V]]:
         return sequence(MapEntry.of(k, v) for k, v in self._inner.items())
@@ -253,6 +253,9 @@ def to_transient(self) -> TransientMap[K, V]:
         return TransientMap(self._inner.mutate())
 
 
+EMPTY: PersistentMap = PersistentMap.from_coll(())
+
+
 def map(  # pylint:disable=redefined-builtin
     kvs: Mapping[K, V], meta: Optional[IPersistentMap] = None
 ) -> PersistentMap[K, V]: