diff --git a/CHANGELOG.md b/CHANGELOG.md index fddc50429..1825afa11 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed * Fix a bug where symbols and keyword containing `:` characters in the name were rejected by the reader (#1105) * Fix a bug where records did not support reducing via `reduce-kv` (#1102) + * Fix a bug where collection modifying library functions such as `conj`, `disj`, `assoc`, `dissoc`, and `empty` would not preserve collection metadata (#1103) ## [v0.3.0] ### Added diff --git a/src/basilisp/contrib/sphinx/autodoc.py b/src/basilisp/contrib/sphinx/autodoc.py index b35872e70..db7d1c11e 100644 --- a/src/basilisp/contrib/sphinx/autodoc.py +++ b/src/basilisp/contrib/sphinx/autodoc.py @@ -380,7 +380,7 @@ def get_object_members(self, want_all: bool) -> tuple[bool, list[ObjectMember]]: assert isinstance(proto, IPersistentMap) proto_methods = cast( IPersistentMap[kw.Keyword, Any], - proto.val_at(_METHODS_KW, lmap.PersistentMap.empty()), + proto.val_at(_METHODS_KW, lmap.EMPTY), ) return False, list( map( diff --git a/src/basilisp/lang/atom.py b/src/basilisp/lang/atom.py index 448da44cb..dbf85306e 100644 --- a/src/basilisp/lang/atom.py +++ b/src/basilisp/lang/atom.py @@ -3,8 +3,8 @@ from typing_extensions import Concatenate, ParamSpec +from basilisp.lang import map as lmap from basilisp.lang.interfaces import IPersistentMap, RefValidator -from basilisp.lang.map import PersistentMap from basilisp.lang.reference import RefBase T = TypeVar("T") @@ -23,7 +23,7 @@ def __init__( self._meta: Optional[IPersistentMap] = meta self._state = state self._lock = threading.RLock() - self._watches = PersistentMap.empty() + self._watches = lmap.EMPTY self._validator = validator if validator is not None: diff --git a/src/basilisp/lang/compiler/analyzer.py b/src/basilisp/lang/compiler/analyzer.py index 471b477c4..33413b8d2 100644 --- a/src/basilisp/lang/compiler/analyzer.py +++ b/src/basilisp/lang/compiler/analyzer.py @@ -331,7 +331,7 @@ def __init__( self._func_ctx: collections.deque[FunctionContext] = collections.deque([]) self._is_quoted: collections.deque[bool] = collections.deque([]) self._opts = ( - Maybe(opts).map(lmap.map).or_else_get(lmap.PersistentMap.empty()) # type: ignore[arg-type, unused-ignore] + Maybe(opts).map(lmap.map).or_else_get(lmap.EMPTY) # type: ignore[arg-type, unused-ignore] ) self._recur_points: collections.deque[RecurPoint] = collections.deque([]) self._should_macroexpand = should_macroexpand @@ -808,7 +808,7 @@ def _call_args_ast( kwargs = lmap.map(kw_map) else: args = vec.vector(map(lambda form: _analyze_form(form, ctx), form)) - kwargs = lmap.PersistentMap.empty() + kwargs = lmap.EMPTY return args, kwargs @@ -940,7 +940,7 @@ def _def_ast( # pylint: disable=too-many-locals,too-many-statements if nelems == 2: init_idx = None doc = None - children = vec.PersistentVector.empty() + children = vec.EMPTY elif nelems == 3: init_idx = 2 doc = None @@ -2823,9 +2823,7 @@ def __letfn_fn_body(form: ISeq, ctx: AnalyzerContext) -> Fn: fn_body = _analyze_form( fn_rest.cons( fn_name.with_meta( - (fn_name.meta or lmap.PersistentMap.empty()).assoc( - SYM_NO_WARN_ON_SHADOW_META_KEY, True - ) + (fn_name.meta or lmap.EMPTY).assoc(SYM_NO_WARN_ON_SHADOW_META_KEY, True) ) ).cons(fn_sym), ctx, @@ -3456,7 +3454,7 @@ def _yield_ast(form: ISeq, ctx: AnalyzerContext) -> Yield: @_analyze_form.register(ISeq) @_with_loc def _list_node(form: ISeq, ctx: AnalyzerContext) -> Node: - if form == llist.PersistentList.empty(): + if form == llist.EMPTY: with ctx.quoted(): return _const_node(form, ctx) diff --git a/src/basilisp/lang/compiler/nodes.py b/src/basilisp/lang/compiler/nodes.py index 030ed6736..e60399d31 100644 --- a/src/basilisp/lang/compiler/nodes.py +++ b/src/basilisp/lang/compiler/nodes.py @@ -340,7 +340,7 @@ class Await(Node[ReaderLispForm]): children: Sequence[kw.Keyword] = vec.v(EXPR) op: NodeOp = NodeOp.AWAIT top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -355,10 +355,10 @@ class Binding(Node[sym.Symbol], Assignable): is_assignable: bool = False init: Optional[Node] = None meta: NodeMeta = None - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.BINDING top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -371,7 +371,7 @@ class Catch(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(CLASS, LOCAL, BODY) op: NodeOp = NodeOp.CATCH top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -382,10 +382,10 @@ class Const(Node[ReaderLispForm]): is_literal: bool env: NodeEnv meta: NodeMeta = None - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.CONST top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -398,10 +398,10 @@ class Def(Node[SpecialForm]): env: NodeEnv tag: Optional[Node] = None meta: NodeMeta = None - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.DEF top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY DefTypeBase = Union["MaybeClass", "MaybeHostForm", "VarRef"] @@ -416,14 +416,14 @@ class DefType(Node[SpecialForm]): members: Iterable["DefTypeMember"] env: NodeEnv verified_abstract: bool = False - artificially_abstract: IPersistentSet[DefTypeBase] = lset.PersistentSet.empty() + artificially_abstract: IPersistentSet[DefTypeBase] = lset.EMPTY is_frozen: bool = True use_weakref_slot: bool = True meta: NodeMeta = None children: Sequence[kw.Keyword] = vec.v(FIELDS, MEMBERS) op: NodeOp = NodeOp.DEFTYPE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @property def python_member_names(self) -> Iterable[str]: @@ -452,7 +452,7 @@ class DefTypeClassMethod(DefTypeMember): children: Sequence[kw.Keyword] = vec.v(CLASS_LOCAL, PARAMS, BODY) op: NodeOp = NodeOp.DEFTYPE_CLASSMETHOD top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -463,7 +463,7 @@ class DefTypeMethod(DefTypeMember): children: Sequence[kw.Keyword] = vec.v(ARITIES) op: NodeOp = NodeOp.DEFTYPE_METHOD top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -481,7 +481,7 @@ class DefTypeMethodArity(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(THIS_LOCAL, PARAMS, BODY) op: NodeOp = NodeOp.DEFTYPE_METHOD_ARITY top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @property def python_name(self) -> str: @@ -496,7 +496,7 @@ class DefTypeProperty(DefTypeMember): children: Sequence[kw.Keyword] = vec.v(THIS_LOCAL, PARAMS, BODY) op: NodeOp = NodeOp.DEFTYPE_PROPERTY top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -509,7 +509,7 @@ class DefTypeStaticMethod(DefTypeMember): children: Sequence[kw.Keyword] = vec.v(PARAMS, BODY) op: NodeOp = NodeOp.DEFTYPE_STATICMETHOD top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY DefTypePythonMember = Union[DefTypeClassMethod, DefTypeProperty, DefTypeStaticMethod] @@ -526,7 +526,7 @@ class Do(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(STATEMENTS, RET) op: NodeOp = NodeOp.DO top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -543,7 +543,7 @@ class Fn(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(ARITIES) op: NodeOp = NodeOp.FN top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -559,7 +559,7 @@ class FnArity(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(PARAMS, BODY) op: NodeOp = NodeOp.FN_ARITY top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -573,7 +573,7 @@ class HostCall(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(TARGET, ARGS) op: NodeOp = NodeOp.HOST_CALL top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -586,7 +586,7 @@ class HostField(Node[Union[SpecialForm, sym.Symbol]], Assignable): children: Sequence[kw.Keyword] = vec.v(TARGET) op: NodeOp = NodeOp.HOST_FIELD top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -599,7 +599,7 @@ class If(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(TEST, THEN, ELSE) op: NodeOp = NodeOp.IF top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -607,10 +607,10 @@ class Import(Node[SpecialForm]): form: SpecialForm aliases: Iterable["ImportAlias"] env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.IMPORT top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -619,10 +619,10 @@ class ImportAlias(Node[Union[sym.Symbol, vec.PersistentVector]]): name: str alias: Optional[str] env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.IMPORT_ALIAS top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -635,7 +635,7 @@ class Invoke(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(FN, ARGS) op: NodeOp = NodeOp.INVOKE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -647,7 +647,7 @@ class Let(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(BINDINGS, BODY) op: NodeOp = NodeOp.LET top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -659,7 +659,7 @@ class LetFn(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(BINDINGS, BODY) op: NodeOp = NodeOp.LETFN top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -671,10 +671,10 @@ class Local(Node[sym.Symbol], Assignable): is_assignable: bool = False arg_id: Optional[int] = None is_variadic: bool = False - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.LOCAL top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -687,7 +687,7 @@ class Loop(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(BINDINGS, BODY) op: NodeOp = NodeOp.LOOP top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -699,7 +699,7 @@ class Map(Node[IPersistentMap]): children: Sequence[kw.Keyword] = vec.v(KEYS, VALS) op: NodeOp = NodeOp.MAP top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -708,10 +708,10 @@ class MaybeClass(Node[sym.Symbol]): class_: str target: Any env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.MAYBE_CLASS top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -721,10 +721,10 @@ class MaybeHostForm(Node[sym.Symbol]): field: str target: Any env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.MAYBE_HOST_FORM top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen(eq=True) @@ -736,7 +736,7 @@ class PyDict(Node[dict]): children: Sequence[kw.Keyword] = vec.v(KEYS, VALS) op: NodeOp = NodeOp.PY_DICT top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen(eq=True) @@ -747,7 +747,7 @@ class PyList(Node[list]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.PY_LIST top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen(eq=True) @@ -758,7 +758,7 @@ class PySet(Node[Union[frozenset, set]]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.PY_SET top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -769,7 +769,7 @@ class PyTuple(Node[tuple]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.PY_TUPLE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -780,7 +780,7 @@ class Queue(Node[lqueue.PersistentQueue]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.QUEUE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -792,7 +792,7 @@ class Quote(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(EXPR) op: NodeOp = NodeOp.QUOTE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -804,7 +804,7 @@ class Recur(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(EXPRS) op: NodeOp = NodeOp.RECUR top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -814,14 +814,14 @@ class Reify(Node[SpecialForm]): members: Iterable["DefTypeMember"] env: NodeEnv verified_abstract: bool = False - artificially_abstract: IPersistentSet[DefTypeBase] = lset.PersistentSet.empty() + artificially_abstract: IPersistentSet[DefTypeBase] = lset.EMPTY is_frozen: bool = True use_weakref_slot: bool = True meta: NodeMeta = None children: Sequence[kw.Keyword] = vec.v(MEMBERS) op: NodeOp = NodeOp.REIFY top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @property def python_member_names(self) -> Iterable[str]: @@ -834,10 +834,10 @@ class RequireAlias(Node[Union[sym.Symbol, vec.PersistentVector]]): name: str alias: Optional[str] env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.REQUIRE_ALIAS top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -845,10 +845,10 @@ class Require(Node[SpecialForm]): form: SpecialForm aliases: Iterable[RequireAlias] env: NodeEnv - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.REQUIRE top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -859,7 +859,7 @@ class Set(Node[IPersistentSet]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.SET top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -871,7 +871,7 @@ class SetBang(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(TARGET, VAL) op: NodeOp = NodeOp.SET_BANG top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -883,7 +883,7 @@ class Throw(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(EXCEPTION) op: NodeOp = NodeOp.THROW top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -896,7 +896,7 @@ class Try(Node[SpecialForm]): finally_: Optional[Do] = None op: NodeOp = NodeOp.TRY top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -907,10 +907,10 @@ class VarRef(Node[Union[sym.Symbol, ISeq]], Assignable): return_var: bool = False is_assignable: bool = True is_allow_var_indirection: bool = False - children: Sequence[kw.Keyword] = vec.PersistentVector.empty() + children: Sequence[kw.Keyword] = vec.EMPTY op: NodeOp = NodeOp.VAR top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -921,7 +921,7 @@ class Vector(Node[IPersistentVector]): children: Sequence[kw.Keyword] = vec.v(ITEMS) op: NodeOp = NodeOp.VECTOR top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY T_withmeta = TypeVar("T_withmeta", Fn, Map, Queue, Reify, Set, Vector) @@ -936,7 +936,7 @@ class WithMeta(Node[LispForm], Generic[T_withmeta]): children: Sequence[kw.Keyword] = vec.v(META, EXPR) op: NodeOp = NodeOp.WITH_META top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @attr.frozen @@ -947,11 +947,11 @@ class Yield(Node[SpecialForm]): children: Sequence[kw.Keyword] = vec.v(EXPR) op: NodeOp = NodeOp.YIELD top_level: bool = False - raw_forms: IPersistentVector[LispForm] = vec.PersistentVector.empty() + raw_forms: IPersistentVector[LispForm] = vec.EMPTY @classmethod def expressionless(cls, form: SpecialForm, env: NodeEnv): - return cls(form=form, expr=None, env=env, children=vec.PersistentVector.empty()) + return cls(form=form, expr=None, env=env, children=vec.EMPTY) SpecialFormNode = Union[ diff --git a/src/basilisp/lang/interfaces.py b/src/basilisp/lang/interfaces.py index 4a65df421..9102a8933 100644 --- a/src/basilisp/lang/interfaces.py +++ b/src/basilisp/lang/interfaces.py @@ -323,9 +323,8 @@ class IPersistentCollection(ISeqable[T]): def cons(self: Self, *elems: T) -> Self: raise NotImplementedError() - @staticmethod @abstractmethod - def empty() -> "IPersistentCollection[T]": + def empty(self) -> "IPersistentCollection[T]": raise NotImplementedError() diff --git a/src/basilisp/lang/keyword.py b/src/basilisp/lang/keyword.py index 8bd6b1369..adbedcc21 100644 --- a/src/basilisp/lang/keyword.py +++ b/src/basilisp/lang/keyword.py @@ -16,7 +16,7 @@ from basilisp.lang.obj import PrintSettings _LOCK = threading.Lock() -_INTERN: IPersistentMap[int, "Keyword"] = lmap.PersistentMap.empty() +_INTERN: IPersistentMap[int, "Keyword"] = lmap.EMPTY @total_ordering diff --git a/src/basilisp/lang/list.py b/src/basilisp/lang/list.py index fc9fee6e4..efc65e1eb 100644 --- a/src/basilisp/lang/list.py +++ b/src/basilisp/lang/list.py @@ -69,11 +69,10 @@ def cons(self, *elems: T) -> "PersistentList[T]": l = self._inner for elem in elems: l = l.cons(elem) - return PersistentList(l) + return PersistentList(l, meta=self._meta) - @staticmethod - def empty() -> "PersistentList": - return EMPTY + def empty(self) -> "PersistentList": + return EMPTY.with_meta(self._meta) def seq(self) -> Optional[ISeq[T]]: if len(self._inner) == 0: diff --git a/src/basilisp/lang/map.py b/src/basilisp/lang/map.py index 6241abf98..a07f56d13 100644 --- a/src/basilisp/lang/map.py +++ b/src/basilisp/lang/map.py @@ -283,7 +283,7 @@ def assoc(self, *kvs): with self._inner.mutate() as m: for k, v in partition(kvs, 2): m[k] = v - return PersistentMap(m.finish()) + return PersistentMap(m.finish(), meta=self._meta) def contains(self, k): return k in self._inner @@ -295,7 +295,7 @@ def dissoc(self, *ks): del m[k] except KeyError: pass - return PersistentMap(m.finish()) + return PersistentMap(m.finish(), meta=self._meta) def entry(self, k): v = self._inner.get(k, cast("V", _ENTRY_SENTINEL)) @@ -308,7 +308,7 @@ def val_at(self, k, default=None): def update(self, *maps: Mapping[K, V]) -> "PersistentMap": m: _Map = self._inner.update(*(m.items() for m in maps)) - return PersistentMap(m) + return PersistentMap(m, meta=self._meta) def update_with( # type: ignore[return] self, merge_fn: Callable[[V, V], V], *maps: Mapping[K, V] @@ -317,7 +317,7 @@ def update_with( # type: ignore[return] for map in maps: for k, v in map.items(): m.set(k, merge_fn(m[k], v) if k in m else v) - return PersistentMap(m.finish()) + return PersistentMap(m.finish(), meta=self._meta) def cons( # type: ignore[override, return] self, @@ -348,9 +348,8 @@ def cons( # type: ignore[override, return] else: return PersistentMap(m.finish(), meta=self.meta) - @staticmethod - def empty() -> "PersistentMap": - return EMPTY + def empty(self) -> "PersistentMap": + return EMPTY.with_meta(self._meta) def seq(self) -> Optional[ISeq[IMapEntry[K, V]]]: if len(self._inner) == 0: diff --git a/src/basilisp/lang/multifn.py b/src/basilisp/lang/multifn.py index 2815a6abd..5c29c4d56 100644 --- a/src/basilisp/lang/multifn.py +++ b/src/basilisp/lang/multifn.py @@ -3,9 +3,9 @@ from basilisp.lang import map as lmap from basilisp.lang import runtime +from basilisp.lang import set as lset from basilisp.lang import symbol as sym from basilisp.lang.interfaces import IPersistentMap, IPersistentSet, IRef -from basilisp.lang.set import PersistentSet T = TypeVar("T") DispatchFunction = Callable[..., T] @@ -41,9 +41,9 @@ def __init__( self._default = default self._dispatch = dispatch self._lock = threading.Lock() - self._methods: IPersistentMap[T, Method] = lmap.PersistentMap.empty() - self._cache: IPersistentMap[T, Method] = lmap.PersistentMap.empty() - self._prefers: IPersistentMap[T, IPersistentSet[T]] = lmap.PersistentMap.empty() + self._methods: IPersistentMap[T, Method] = lmap.EMPTY + self._cache: IPersistentMap[T, Method] = lmap.EMPTY + self._prefers: IPersistentMap[T, IPersistentSet[T]] = lmap.EMPTY # Fetch some items from basilisp.core that we need to compute the final # dispatch method. These cannot be imported statically because that would @@ -149,7 +149,7 @@ def prefer_method(self, preferred_key: T, other_key: T) -> None: f"due to existing preference for '{other_key}' over " f"'{preferred_key}'" ) - existing = self._prefers.val_at(preferred_key, PersistentSet.empty()) + existing = self._prefers.val_at(preferred_key, lset.EMPTY) assert existing is not None self._prefers = self._prefers.assoc(preferred_key, existing.cons(other_key)) self._reset_cache() @@ -171,7 +171,7 @@ def remove_method(self, key: T) -> Optional[Method]: def remove_all_methods(self) -> None: """Remove all methods defined for this multimethod1.""" with self._lock: - self._methods = lmap.PersistentMap.empty() + self._methods = lmap.EMPTY self._reset_cache() @property diff --git a/src/basilisp/lang/queue.py b/src/basilisp/lang/queue.py index 61225157d..eb7061c2a 100644 --- a/src/basilisp/lang/queue.py +++ b/src/basilisp/lang/queue.py @@ -60,11 +60,10 @@ def with_meta(self, meta: Optional[IPersistentMap]) -> "PersistentQueue": return queue(self._inner, meta=meta) def cons(self, *elems: T) -> "PersistentQueue[T]": - return PersistentQueue(self._inner.extend(elems)) + return PersistentQueue(self._inner.extend(elems), meta=self._meta) - @staticmethod - def empty() -> "PersistentQueue": - return EMPTY + def empty(self) -> "PersistentQueue": + return EMPTY.with_meta(self._meta) def peek(self): try: @@ -75,7 +74,7 @@ def peek(self): def pop(self) -> "PersistentQueue[T]": if len(self._inner) == 0: raise IndexError("Cannot pop an empty queue") - return PersistentQueue(self._inner.popleft()) + return PersistentQueue(self._inner.popleft(), meta=self._meta) def seq(self) -> Optional[ISeq[T]]: if len(self._inner) == 0: diff --git a/src/basilisp/lang/runtime.py b/src/basilisp/lang/runtime.py index 7c9b2961c..59033717f 100644 --- a/src/basilisp/lang/runtime.py +++ b/src/basilisp/lang/runtime.py @@ -250,7 +250,7 @@ def __init__( self._tl = None self._meta = meta self._lock = threading.RLock() - self._watches = lmap.PersistentMap.empty() + self._watches = lmap.EMPTY self._validator = None if dynamic: @@ -460,7 +460,7 @@ def find_safe(cls, ns_qualified_sym: sym.Symbol) -> "Var": class _ThreadBindings(threading.local): def __init__(self): - self._bindings: FrameStack = vec.PersistentVector.empty() + self._bindings: FrameStack = vec.EMPTY def get_bindings(self) -> FrameStack: return self._bindings @@ -558,7 +558,7 @@ class Namespace(ReferenceBase): ) ) - _NAMESPACES: Atom[NamespaceMap] = Atom(lmap.PersistentMap.empty()) + _NAMESPACES: Atom[NamespaceMap] = Atom(lmap.EMPTY) __slots__ = ( "_name", @@ -581,7 +581,7 @@ def __init__( self._meta: Optional[IPersistentMap] = None self._lock = threading.RLock() - self._aliases: NamespaceMap = lmap.PersistentMap.empty() + self._aliases: NamespaceMap = lmap.EMPTY self._imports: ModuleMap = lmap.map( dict( map( @@ -590,9 +590,9 @@ def __init__( ) ) ) - self._import_aliases: AliasMap = lmap.PersistentMap.empty() - self._interns: VarMap = lmap.PersistentMap.empty() - self._refers: VarMap = lmap.PersistentMap.empty() + self._import_aliases: AliasMap = lmap.EMPTY + self._interns: VarMap = lmap.EMPTY + self._refers: VarMap = lmap.EMPTY @property def name(self) -> str: @@ -1435,7 +1435,7 @@ def assoc(m, *kvs): @assoc.register(type(None)) def _assoc_none(_: None, *kvs) -> lmap.PersistentMap: - return lmap.PersistentMap.empty().assoc(*kvs) + return lmap.EMPTY.assoc(*kvs) @assoc.register(IAssociative) @@ -1455,7 +1455,7 @@ def update(m, k, f, *args): @update.register(type(None)) def _update_none(_: None, k, f, *args) -> lmap.PersistentMap: - return lmap.PersistentMap.empty().assoc(k, f(None, *args)) + return lmap.EMPTY.assoc(k, f(None, *args)) @update.register(IAssociative) @@ -1550,7 +1550,7 @@ def conj(coll, *xs): @conj.register(type(None)) def _conj_none(_: None, *xs): - l = llist.PersistentList.empty() + l = llist.EMPTY return l.cons(*xs) diff --git a/src/basilisp/lang/seq.py b/src/basilisp/lang/seq.py index 516e3e50d..b7c56c428 100644 --- a/src/basilisp/lang/seq.py +++ b/src/basilisp/lang/seq.py @@ -55,8 +55,7 @@ def cons(self, *elems: T) -> ISeq[T]: # type: ignore[override] l = Cons(elem, l) return l - @staticmethod - def empty(): + def empty(self): return EMPTY @@ -94,8 +93,7 @@ def cons(self, *elems: T) -> "Cons[T]": l = Cons(elem, l) return l - @staticmethod - def empty(): + def empty(self): return EMPTY @property @@ -216,8 +214,7 @@ def is_realized(self): with self._lock: return self._gen is None - @staticmethod - def empty(): + def empty(self): return EMPTY diff --git a/src/basilisp/lang/set.py b/src/basilisp/lang/set.py index 414f9ac5e..8029d5b0d 100644 --- a/src/basilisp/lang/set.py +++ b/src/basilisp/lang/set.py @@ -166,9 +166,8 @@ def disj(self, *elems: T) -> "PersistentSet[T]": # type: ignore[return] pass return PersistentSet(m.finish(), meta=self.meta) - @staticmethod - def empty() -> "PersistentSet": - return EMPTY + def empty(self) -> "PersistentSet": + return EMPTY.with_meta(self._meta) def seq(self) -> Optional[ISeq[T]]: if len(self._inner) == 0: diff --git a/src/basilisp/lang/vector.py b/src/basilisp/lang/vector.py index 569c13c84..e8cb4d4cc 100644 --- a/src/basilisp/lang/vector.py +++ b/src/basilisp/lang/vector.py @@ -177,7 +177,7 @@ def cons(self, *elems: T) -> "PersistentVector[T]": # type: ignore[override] return PersistentVector(e.persistent(), meta=self.meta) def assoc(self, *kvs: T) -> "PersistentVector[T]": - return PersistentVector(self._inner.mset(*kvs)) # type: ignore[arg-type] + return PersistentVector(self._inner.mset(*kvs), meta=self._meta) # type: ignore[arg-type] def contains(self, k: int) -> bool: return 0 <= k < len(self._inner) @@ -194,9 +194,8 @@ def val_at(self, k: int, default: Optional[T] = None) -> Optional[T]: except (IndexError, TypeError): return default - @staticmethod - def empty() -> "PersistentVector[T]": - return EMPTY + def empty(self) -> "PersistentVector[T]": + return EMPTY.with_meta(self._meta) def seq(self) -> Optional[ISeq[T]]: # type: ignore[override] if len(self._inner) == 0: diff --git a/tests/basilisp/atom_test.py b/tests/basilisp/atom_test.py index cfe6c62f3..c79ab61c0 100644 --- a/tests/basilisp/atom_test.py +++ b/tests/basilisp/atom_test.py @@ -24,8 +24,8 @@ def test_atom_deref_interface(interface): def test_atom(): - a = atom.Atom(vec.PersistentVector.empty()) - assert vec.PersistentVector.empty() == a.deref() + a = atom.Atom(vec.EMPTY) + assert vec.EMPTY == a.deref() assert vec.v(1) == a.swap(lambda v, e: v.cons(e), 1) assert vec.v(1) == a.deref() @@ -33,11 +33,11 @@ def test_atom(): assert vec.v(1, 2) == a.swap(lambda v, e: v.cons(e), 2) assert vec.v(1, 2) == a.deref() - assert lmap.PersistentMap.empty() == a.reset(lmap.PersistentMap.empty()) - assert lmap.PersistentMap.empty() == a.deref() + assert lmap.EMPTY == a.reset(lmap.EMPTY) + assert lmap.EMPTY == a.deref() - assert False is a.compare_and_set("not a map", vec.PersistentVector.empty()) - assert True is a.compare_and_set(lmap.PersistentMap.empty(), "new string") + assert False is a.compare_and_set("not a map", vec.EMPTY) + assert True is a.compare_and_set(lmap.EMPTY, "new string") assert "new string" == a.deref() diff --git a/tests/basilisp/compiler_test.py b/tests/basilisp/compiler_test.py index 7b7d3c004..3806acc46 100644 --- a/tests/basilisp/compiler_test.py +++ b/tests/basilisp/compiler_test.py @@ -3242,8 +3242,8 @@ def test_macroexpand_1(self, lcompile: CompileFn, example_macro): assert llist.l( sym.symbol("defmacro", ns="basilisp.core"), sym.symbol("child"), - vec.PersistentVector.empty(), - llist.l(sym.symbol("fn", ns="basilisp.core"), vec.PersistentVector.empty()), + vec.EMPTY, + llist.l(sym.symbol("fn", ns="basilisp.core"), vec.EMPTY), ) == compiler.macroexpand_1(llist.l(sym.symbol("parent"))) assert llist.l( @@ -3253,9 +3253,7 @@ def test_macroexpand_1(self, lcompile: CompileFn, example_macro): assert llist.l(sym.symbol("map")) == compiler.macroexpand_1( llist.l(sym.symbol("map")) ) - assert vec.PersistentVector.empty() == compiler.macroexpand_1( - vec.PersistentVector.empty() - ) + assert vec.EMPTY == compiler.macroexpand_1(vec.EMPTY) assert sym.symbol("non-existent-symbol") == compiler.macroexpand_1( sym.symbol("non-existent-symbol") @@ -3280,7 +3278,7 @@ def test_macroexpand(self, lcompile: CompileFn, example_macro): vec.v(sym.symbol("&env"), sym.symbol("&form")), llist.l( sym.symbol("fn", ns="basilisp.core"), - vec.PersistentVector.empty(), + vec.EMPTY, ), ), ) == compiler.macroexpand(llist.l(sym.symbol("parent"), meta=meta)) @@ -3292,9 +3290,7 @@ def test_macroexpand(self, lcompile: CompileFn, example_macro): assert llist.l(sym.symbol("map")) == compiler.macroexpand( llist.l(sym.symbol("map"), meta=meta) ) - assert vec.PersistentVector.empty() == compiler.macroexpand( - vec.PersistentVector.empty().with_meta(meta) - ) + assert vec.EMPTY == compiler.macroexpand(vec.EMPTY.with_meta(meta)) assert sym.symbol("non-existent-symbol") == compiler.macroexpand( sym.symbol("non-existent-symbol") @@ -4221,7 +4217,7 @@ def test_quoted_list(self, lcompile: CompileFn): ) def test_quoted_map(self, lcompile: CompileFn): - assert lcompile("'{}") == lmap.PersistentMap.empty() + assert lcompile("'{}") == lmap.EMPTY assert lcompile("'{:a 2}") == lmap.map({kw.keyword("a"): 2}) assert lcompile('\'{:a 2 "str" s}') == lmap.map( {kw.keyword("a"): 2, "str": sym.symbol("s")} @@ -4235,7 +4231,7 @@ def test_quoted_queue(self, lcompile: CompileFn): assert lcompile("'#queue (1 2 3)") == lqueue.q(1, 2, 3) def test_quoted_set(self, lcompile: CompileFn): - assert lcompile("'#{}") == lset.PersistentSet.empty() + assert lcompile("'#{}") == lset.EMPTY assert lcompile("'#{:a 2}") == lset.s(kw.keyword("a"), 2) assert lcompile('\'#{:a 2 "str"}') == lset.s(kw.keyword("a"), 2, "str") diff --git a/tests/basilisp/core_test.py b/tests/basilisp/core_test.py index 516b40e62..f7af5b516 100644 --- a/tests/basilisp/core_test.py +++ b/tests/basilisp/core_test.py @@ -45,19 +45,19 @@ def setup_module(): kw.keyword("name", ns="ns"), "", "not empty", - llist.PersistentList.empty(), + llist.EMPTY, llist.l(0), llist.l(False), llist.l(True), - lmap.PersistentMap.empty(), + lmap.EMPTY, lmap.map({0: 0}), lmap.map({False: False}), lmap.map({True: True}), - lset.PersistentSet.empty(), + lset.EMPTY, lset.s(0), lset.s(False), lset.s(True), - vec.PersistentVector.empty(), + vec.EMPTY, vec.v(0), vec.v(False), vec.v(True), @@ -80,19 +80,19 @@ def setup_module(): kw.keyword("name", ns="ns"), "", "not empty", - llist.PersistentList.empty(), + llist.EMPTY, llist.l(0), llist.l(False), llist.l(True), - lmap.PersistentMap.empty(), + lmap.EMPTY, lmap.map({0: 0}), lmap.map({False: False}), lmap.map({True: True}), - lset.PersistentSet.empty(), + lset.EMPTY, lset.s(0), lset.s(False), lset.s(True), - vec.PersistentVector.empty(), + vec.EMPTY, vec.v(0), vec.v(False), vec.v(True), @@ -197,12 +197,12 @@ def test_ex_info(): def test_last(): - assert None is core.last(llist.PersistentList.empty()) + assert None is core.last(llist.EMPTY) assert 1 == core.last(llist.l(1)) assert 2 == core.last(llist.l(1, 2)) assert 3 == core.last(llist.l(1, 2, 3)) - assert None is core.last(vec.PersistentVector.empty()) + assert None is core.last(vec.EMPTY) assert 1 == core.last(vec.v(1)) assert 2 == core.last(vec.v(1, 2)) assert 3 == core.last(vec.v(1, 2, 3)) @@ -527,15 +527,11 @@ def test_any_always_true(self, lisp_value): class TestIsAssociative: - @pytest.mark.parametrize( - "v", [lmap.PersistentMap.empty(), vec.PersistentVector.empty()] - ) + @pytest.mark.parametrize("v", [lmap.EMPTY, vec.EMPTY]) def test_is_associative(self, v): assert True is core.associative__Q__(v) - @pytest.mark.parametrize( - "v", [llist.PersistentList.empty(), lset.PersistentSet.empty()] - ) + @pytest.mark.parametrize("v", [llist.EMPTY, lset.EMPTY]) def test_is_not_associative(self, v): assert False is core.associative__Q__(v) @@ -563,10 +559,10 @@ class TestIsColl: @pytest.mark.parametrize( "v", [ - llist.PersistentList.empty(), - lmap.PersistentMap.empty(), - lset.PersistentSet.empty(), - vec.PersistentVector.empty(), + llist.EMPTY, + lmap.EMPTY, + lset.EMPTY, + vec.EMPTY, ], ) def test_is_coll(self, v): @@ -613,10 +609,10 @@ def test_is_fn(self, basilisp_fn, py_fn): 1, 1.6, kw.keyword("a"), - lmap.PersistentMap.empty(), - lset.PersistentSet.empty(), + lmap.EMPTY, + lset.EMPTY, sym.symbol("a"), - vec.PersistentVector.empty(), + vec.EMPTY, ], ) def test_is_not_fn(self, v): @@ -626,9 +622,7 @@ def test_function_is_ifn(self, basilisp_fn, py_fn): assert True is core.ifn__Q__(basilisp_fn) assert True is core.ifn__Q__(py_fn) - @pytest.mark.parametrize( - "v", [kw.keyword("a"), lmap.PersistentMap.empty(), lset.PersistentSet.empty()] - ) + @pytest.mark.parametrize("v", [kw.keyword("a"), lmap.EMPTY, lset.EMPTY]) def test_other_is_ifn(self, v): assert True is core.ifn__Q__(v) @@ -707,7 +701,7 @@ def test_is_qualified_symbol(self, v): def test_is_map_entry(): assert True is core.map_entry__Q__(lmap.MapEntry.of("a", "b")) - assert False is core.map_entry__Q__(vec.PersistentVector.empty()) + assert False is core.map_entry__Q__(vec.EMPTY) assert False is core.map_entry__Q__(vec.v("a", "b")) assert False is core.map_entry__Q__(vec.v("a", "b", "c")) @@ -911,7 +905,7 @@ class TestIsPy: def test_is_py_dict(self, v): assert True is core.py_dict__Q__(v) - @pytest.mark.parametrize("v", [lmap.PersistentMap.empty(), lmap.map({"a": "b"})]) + @pytest.mark.parametrize("v", [lmap.EMPTY, lmap.map({"a": "b"})]) def test_is_not_py_dict(self, v): assert False is core.py_dict__Q__(v) @@ -919,7 +913,7 @@ def test_is_not_py_dict(self, v): def test_is_py_frozenset(self, v): assert True is core.py_frozenset__Q__(v) - @pytest.mark.parametrize("v", [lset.PersistentSet.empty(), lset.s("a", "b")]) + @pytest.mark.parametrize("v", [lset.EMPTY, lset.s("a", "b")]) def test_is_not_py_frozenset(self, v): assert False is core.py_frozenset__Q__(v) @@ -927,7 +921,7 @@ def test_is_not_py_frozenset(self, v): def test_is_py_list(self, v): assert True is core.py_list__Q__(v) - @pytest.mark.parametrize("v", [vec.PersistentVector.empty(), vec.v("a", "b")]) + @pytest.mark.parametrize("v", [vec.EMPTY, vec.v("a", "b")]) def test_is_not_py_list(self, v): assert False is core.py_list__Q__(v) @@ -935,7 +929,7 @@ def test_is_not_py_list(self, v): def test_is_py_set(self, v): assert True is core.py_set__Q__(v) - @pytest.mark.parametrize("v", [lset.PersistentSet.empty(), lset.s("a", "b")]) + @pytest.mark.parametrize("v", [lset.EMPTY, lset.s("a", "b")]) def test_is_not_py_set(self, v): assert False is core.py_set__Q__(v) @@ -943,7 +937,7 @@ def test_is_not_py_set(self, v): def test_is_py_tuple(self, v): assert True is core.py_tuple__Q__(v) - @pytest.mark.parametrize("v", [llist.PersistentList.empty(), llist.l("a", "b")]) + @pytest.mark.parametrize("v", [llist.EMPTY, llist.l("a", "b")]) def test_is_not_py_tuple(self, v): assert False is core.py_tuple__Q__(v) @@ -1151,15 +1145,15 @@ def test_disj(self): assert None is core.disj(None) assert None is core.disj(None, "a") assert None is core.disj(None, "a", "b", "c") - assert lset.PersistentSet.empty() == core.disj(lset.PersistentSet.empty(), "a") - assert lset.PersistentSet.empty() == core.disj(lset.s("a"), "a") + assert lset.EMPTY == core.disj(lset.EMPTY, "a") + assert lset.EMPTY == core.disj(lset.s("a"), "a") assert lset.s("b", "d") == core.disj(lset.s("a", "b", "c", "d"), "a", "c", "e") def test_dissoc(self): assert None is core.dissoc(None) assert None is core.dissoc(None, "a") assert None is core.dissoc(None, "a", "b", "c") - assert lmap.PersistentMap.empty() == core.dissoc(lmap.map({"a": 1}), "a", "c") + assert lmap.EMPTY == core.dissoc(lmap.map({"a": 1}), "a", "c") assert lmap.map({"a": 1}) == core.dissoc(lmap.map({"a": 1}), "b", "c") def test_get(self): @@ -1216,7 +1210,7 @@ def test_assoc_in(self): lmap.map({"f": 6}), ) - assert vec.v("a") == core.assoc_in(vec.PersistentVector.empty(), vec.v(0), "a") + assert vec.v("a") == core.assoc_in(vec.EMPTY, vec.v(0), "a") assert vec.v("c", "b") == core.assoc_in(vec.v("a", "b"), vec.v(0), "c") assert vec.v("a", "c") == core.assoc_in(vec.v("a", "b"), vec.v(1), "c") assert vec.v("a", "d", "c") == core.assoc_in( @@ -1343,11 +1337,9 @@ def test_update_in(self): ) def test_select_keys(self): - assert lmap.PersistentMap.empty() == core.select_keys( - lmap.PersistentMap.empty(), vec.PersistentVector.empty() - ) - assert lmap.PersistentMap.empty() == core.select_keys( - lmap.PersistentMap.empty(), vec.v(kw.keyword("a"), kw.keyword("b")) + assert lmap.EMPTY == core.select_keys(lmap.EMPTY, vec.EMPTY) + assert lmap.EMPTY == core.select_keys( + lmap.EMPTY, vec.v(kw.keyword("a"), kw.keyword("b")) ) assert lmap.map( {kw.keyword("a"): "a", kw.keyword("b"): "b"} @@ -1429,9 +1421,7 @@ def test_partial_kw(): class TestIsEvery: - @pytest.mark.parametrize( - "coll", [vec.PersistentVector.empty(), vec.v(3), vec.v(3, 5, 7, 9, 11)] - ) + @pytest.mark.parametrize("coll", [vec.EMPTY, vec.v(3), vec.v(3, 5, 7, 9, 11)]) def test_is_every(self, coll): assert True is core.every__Q__(core.odd__Q__, coll) @@ -1444,9 +1434,7 @@ def test_is_not_every(self, coll): class TestIsNotEvery: - @pytest.mark.parametrize( - "coll", [vec.PersistentVector.empty(), vec.v(3), vec.v(3, 5, 7, 9, 11)] - ) + @pytest.mark.parametrize("coll", [vec.EMPTY, vec.v(3), vec.v(3, 5, 7, 9, 11)]) def test_is_not_every(self, coll): assert False is core.not_every__Q__(core.odd__Q__, coll) @@ -1472,9 +1460,7 @@ class TestSome: def test_is_some(self, coll): assert True is core.some(core.odd__Q__, coll) - @pytest.mark.parametrize( - "coll", [vec.PersistentVector.empty(), vec.v(2), vec.v(2, 4, 6, 8, 10)] - ) + @pytest.mark.parametrize("coll", [vec.EMPTY, vec.v(2), vec.v(2, 4, 6, 8, 10)]) def test_is_not_some(self, coll): assert None is core.some(core.odd__Q__, coll) @@ -1493,9 +1479,7 @@ class TestNotAny: def test_is_not_any(self, coll): assert False is core.not_any__Q__(core.odd__Q__, coll) - @pytest.mark.parametrize( - "coll", [vec.PersistentVector.empty(), vec.v(2), vec.v(2, 4, 6, 8, 10)] - ) + @pytest.mark.parametrize("coll", [vec.EMPTY, vec.v(2), vec.v(2, 4, 6, 8, 10)]) def test_not_is_not_any(self, coll): assert True is core.not_any__Q__(core.odd__Q__, coll) @@ -1561,7 +1545,7 @@ def test_string_format(): def test_merge(): assert None is core.merge() - assert lmap.PersistentMap.empty() == core.merge(lmap.PersistentMap.empty()) + assert lmap.EMPTY == core.merge(lmap.EMPTY) assert lmap.map({kw.keyword("a"): 1}) == core.merge(lmap.map({kw.keyword("a"): 1})) assert lmap.map({kw.keyword("a"): 53, kw.keyword("b"): "hi"}) == core.merge( lmap.map({kw.keyword("a"): 1, kw.keyword("b"): "hi"}), @@ -1570,42 +1554,30 @@ def test_merge(): def test_split_at(): - assert vec.v( - llist.PersistentList.empty(), llist.PersistentList.empty() - ) == core.split_at(3, vec.PersistentVector.empty()) - assert vec.v(llist.PersistentList.empty(), llist.l(1, 2, 3)) == core.split_at( - 0, vec.v(1, 2, 3) - ) + assert vec.v(llist.EMPTY, llist.EMPTY) == core.split_at(3, vec.EMPTY) + assert vec.v(llist.EMPTY, llist.l(1, 2, 3)) == core.split_at(0, vec.v(1, 2, 3)) assert vec.v(llist.l(1), llist.l(2, 3)) == core.split_at(1, vec.v(1, 2, 3)) assert vec.v(llist.l(1, 2), llist.l(3)) == core.split_at(2, vec.v(1, 2, 3)) - assert vec.v(llist.l(1, 2, 3), llist.PersistentList.empty()) == core.split_at( - 3, vec.v(1, 2, 3) - ) - assert vec.v(llist.l(1, 2, 3), llist.PersistentList.empty()) == core.split_at( - 4, vec.v(1, 2, 3) - ) + assert vec.v(llist.l(1, 2, 3), llist.EMPTY) == core.split_at(3, vec.v(1, 2, 3)) + assert vec.v(llist.l(1, 2, 3), llist.EMPTY) == core.split_at(4, vec.v(1, 2, 3)) assert vec.v(llist.l(1, 2, 3), llist.l(4)) == core.split_at(3, vec.v(1, 2, 3, 4)) def test_split_with(): - assert vec.v( - llist.PersistentList.empty(), llist.PersistentList.empty() - ) == core.split_with(core.odd__Q__, vec.PersistentVector.empty()) + assert vec.v(llist.EMPTY, llist.EMPTY) == core.split_with(core.odd__Q__, vec.EMPTY) assert vec.v(llist.l(1), llist.l(2, 3)) == core.split_with( core.odd__Q__, vec.v(1, 2, 3) ) - assert vec.v(llist.l(1, 3, 5, 7), llist.PersistentList.empty()) == core.split_with( + assert vec.v(llist.l(1, 3, 5, 7), llist.EMPTY) == core.split_with( core.odd__Q__, vec.v(1, 3, 5, 7) ) - assert vec.v(llist.PersistentList.empty(), llist.l(2, 4, 6, 8)) == core.split_with( + assert vec.v(llist.EMPTY, llist.l(2, 4, 6, 8)) == core.split_with( core.odd__Q__, vec.v(2, 4, 6, 8) ) def test_group_by(): - assert lmap.PersistentMap.empty() == core.group_by( - core.inc, vec.PersistentVector.empty() - ) + assert lmap.EMPTY == core.group_by(core.inc, vec.EMPTY) assert lmap.map({True: vec.v(1, 3), False: vec.v(2, 4)}) == core.group_by( core.odd__Q__, vec.v(1, 2, 3, 4) ) diff --git a/tests/basilisp/keyword_test.py b/tests/basilisp/keyword_test.py index 27538e52e..e7fffd35c 100644 --- a/tests/basilisp/keyword_test.py +++ b/tests/basilisp/keyword_test.py @@ -86,7 +86,7 @@ def test_keyword_pickleability(pickle_protocol: int, o: Keyword): class TestKeywordCompletion: @pytest.fixture def empty_cache(self) -> lmap.PersistentMap[int, Keyword]: - return lmap.PersistentMap.empty() + return lmap.EMPTY def test_empty_cache_no_completion( self, empty_cache: lmap.PersistentMap[int, Keyword] diff --git a/tests/basilisp/list_test.py b/tests/basilisp/list_test.py index 4c34b6b62..cde213d3f 100644 --- a/tests/basilisp/list_test.py +++ b/tests/basilisp/list_test.py @@ -41,7 +41,7 @@ def test_list_slice(): def test_list_bool(): - assert True is bool(llist.PersistentList.empty()) + assert True is bool(llist.EMPTY) def test_list_cons(): @@ -53,9 +53,18 @@ def test_list_cons(): assert l2 == llist.l(keyword("kw2"), keyword("kw1")) assert len(l2) == 2 assert meta == l1.meta - assert l2.meta is None + assert l2.meta == meta l3 = l2.cons(3, "four") assert l3 == llist.l("four", 3, keyword("kw2"), keyword("kw1")) + assert l3.meta == meta + + +def test_list_empty(): + meta = lmap.m(tag="async") + l1 = llist.l(keyword("kw1"), meta=meta) + assert l1.empty() == llist.EMPTY + assert l1.empty().meta == meta + assert llist.EMPTY.empty().meta is None def test_peek(): @@ -70,7 +79,7 @@ def test_pop(): with pytest.raises(IndexError): llist.l().pop() - assert llist.PersistentList.empty() == llist.l(1).pop() + assert llist.EMPTY == llist.l(1).pop() assert llist.l(2) == llist.l(1, 2).pop() assert llist.l(2, 3) == llist.l(1, 2, 3).pop() @@ -103,14 +112,14 @@ def test_list_with_meta(): def test_list_seq(): - assert None is llist.PersistentList.empty().seq() + assert None is llist.EMPTY.seq() assert llist.l(1) == llist.l(1).seq() assert llist.l(1, 2) == llist.l(1, 2).seq() assert llist.l(1, 2, 3) == llist.l(1, 2, 3).seq() def test_list_first(): - assert None is llist.PersistentList.empty().first + assert None is llist.EMPTY.first assert None is llist.l().first assert 1 == llist.l(1).first assert 1 == llist.l(1, 2).first diff --git a/tests/basilisp/map_test.py b/tests/basilisp/map_test.py index d15bccb3d..9e30e4499 100644 --- a/tests/basilisp/map_test.py +++ b/tests/basilisp/map_test.py @@ -48,16 +48,21 @@ def test_map_interface_membership(interface): def test_assoc(): m = lmap.m() assert lmap.map({"k": 1}) == m.assoc("k", 1) - assert lmap.PersistentMap.empty() == m + assert lmap.EMPTY == m assert lmap.map({"a": 1, "b": 2}) == m.assoc("a", 1, "b", 2) m1 = lmap.map({"a": 3}) assert lmap.map({"a": 1, "b": 2}) == m1.assoc("a", 1, "b", 2) assert lmap.map({"a": 3, "b": 2}) == m1.assoc("b", 2) + meta = lmap.map({"meta": True}) + m2 = lmap.map({"b": 3}, meta=meta) + assert m2.assoc("b", 4).meta == meta + assert m2.assoc("c", 8, "d", 12).meta == meta + def test_map_bool(): - assert True is bool(lmap.PersistentMap.empty()) + assert True is bool(lmap.EMPTY) def test_map_as_function(): @@ -71,35 +76,45 @@ def test_map_as_function(): def test_contains(): assert True is lmap.map({"a": 1}).contains("a") assert False is lmap.map({"a": 1}).contains("b") - assert False is lmap.PersistentMap.empty().contains("a") + assert False is lmap.EMPTY.contains("a") def test_dissoc(): - assert lmap.PersistentMap.empty() == lmap.PersistentMap.empty().dissoc("a") - assert lmap.PersistentMap.empty() == lmap.PersistentMap.empty().dissoc( - "a", "b", "c" - ) + assert lmap.EMPTY == lmap.EMPTY.dissoc("a") + assert lmap.EMPTY == lmap.EMPTY.dissoc("a", "b", "c") m1 = lmap.map({"a": 3}) assert m1 == m1.dissoc("b") - assert lmap.PersistentMap.empty() == m1.dissoc("a") + assert lmap.EMPTY == m1.dissoc("a") - m2 = lmap.map({"a": 3, "b": 2}) + meta = lmap.map({"meta": True}) + m2 = lmap.map({"a": 3, "b": 2}, meta=meta) assert lmap.map({"a": 3}) == m2.dissoc("b") + assert m2.dissoc("b").meta == meta assert lmap.map({"b": 2}) == m2.dissoc("a") - assert lmap.PersistentMap.empty() == m2.dissoc("a", "b") + assert m2.dissoc("a").meta == meta + assert lmap.EMPTY == m2.dissoc("a", "b") + assert m2.dissoc("a", "b").meta == meta + + +def test_map_empty(): + meta = lmap.map({"meta": 1}) + m1 = lmap.map({"a": 1}, meta=meta) + assert m1.empty() == lmap.EMPTY + assert m1.empty().meta == meta + assert lmap.EMPTY.meta is None def test_entry(): assert MapEntry.of("a", 1) == lmap.map({"a": 1}).entry("a") assert None is lmap.map({"a": 1}).entry("b") - assert None is lmap.PersistentMap.empty().entry("a") + assert None is lmap.EMPTY.entry("a") def test_val_at(): assert 1 == lmap.map({"a": 1}).val_at("a") assert None is lmap.map({"a": 1}).val_at("b") - assert None is lmap.PersistentMap.empty().val_at("a") + assert None is lmap.EMPTY.val_at("a") def test_map_cons(): @@ -190,7 +205,7 @@ def test_map_with_meta(): def test_map_seq(): - assert None is lmap.PersistentMap.empty().seq() + assert None is lmap.EMPTY.seq() assert {v("a", 1)} == set(lmap.map({"a": 1}).seq()) assert {v("a", 1), v("b", 2)} == set(lmap.map({"a": 1, "b": 2}).seq()) assert {v("a", 1), v("b", 2), v("c", 3)} == set( diff --git a/tests/basilisp/multifn_test.py b/tests/basilisp/multifn_test.py index f1bccdaf6..b72bdaaf1 100644 --- a/tests/basilisp/multifn_test.py +++ b/tests/basilisp/multifn_test.py @@ -60,7 +60,7 @@ def fn_default(v) -> str: f.remove_all_methods() - assert lmap.PersistentMap.empty() == f.methods + assert lmap.EMPTY == f.methods with pytest.raises(NotImplementedError): f("blah") diff --git a/tests/basilisp/queue_test.py b/tests/basilisp/queue_test.py index 4aee9d7e8..9dd5d56a3 100644 --- a/tests/basilisp/queue_test.py +++ b/tests/basilisp/queue_test.py @@ -35,7 +35,7 @@ def test_queue_interface_membership(interface): def test_queue_bool(): - assert True is bool(lqueue.PersistentQueue.empty()) + assert True is bool(lqueue.EMPTY) def test_queue_cons(): @@ -47,19 +47,28 @@ def test_queue_cons(): assert q2 == lqueue.q(keyword("kw1"), keyword("kw2")) assert len(q2) == 2 assert meta == q1.meta - assert q2.meta is None + assert q2.meta == meta q3 = q2.cons(3, "four") assert q3 == lqueue.q(keyword("kw1"), keyword("kw2"), 3, "four") + assert q3.meta == meta + + +def test_queue_empty(): + meta = lmap.m(tag="async") + q1 = lqueue.q(keyword("kw1"), meta=meta) + assert q1.empty() == lqueue.EMPTY + assert q1.empty().meta == meta + assert lqueue.EMPTY.empty().meta is None def test_queue_equals(): - q = lqueue.PersistentQueue.empty() + q = lqueue.EMPTY assert q == q assert lqueue.q(1, 2, 3) != (1, 2, 3, 4) def test_queue_peek(): - assert None is lqueue.PersistentQueue.empty().peek() + assert None is lqueue.EMPTY.peek() assert 1 == lqueue.q(1).peek() assert 1 == lqueue.q(1, 2).peek() @@ -70,10 +79,16 @@ def test_queue_pop(): with pytest.raises(IndexError): lqueue.q().pop() - assert lqueue.PersistentQueue.empty() == lqueue.q(1).pop() + assert lqueue.EMPTY == lqueue.q(1).pop() assert lqueue.q(2) == lqueue.q(1, 2).pop() assert lqueue.q(2, 3) == lqueue.q(1, 2, 3).pop() + meta = lmap.m(meta=True) + q1 = lqueue.q(1, 2, 3, meta=meta) + assert q1.pop().meta == meta + assert q1.pop().pop().meta == meta + assert q1.pop().pop().pop().meta == meta + def test_queue_meta(): assert lqueue.q("vec").meta is None @@ -103,7 +118,7 @@ def test_queue_with_meta(): def test_queue_seq(): - assert None is lqueue.PersistentQueue.empty().seq() + assert None is lqueue.EMPTY.seq() assert lqueue.q(1) == lqueue.q(1).seq() assert lqueue.q(1, 2) == lqueue.q(1, 2).seq() assert lqueue.q(1, 2, 3) == lqueue.q(1, 2, 3).seq() @@ -126,7 +141,7 @@ def test_queue_pickleability(pickle_protocol: int, o: lqueue.PersistentQueue): @pytest.mark.parametrize( "l,str_repr", [ - (lqueue.PersistentQueue.empty(), "#queue ()"), + (lqueue.EMPTY, "#queue ()"), (lqueue.q(keyword("kw1")), "#queue (:kw1)"), (lqueue.q(keyword("kw1"), keyword("kw2")), "#queue (:kw1 :kw2)"), ], diff --git a/tests/basilisp/reader_test.py b/tests/basilisp/reader_test.py index 954cc75c0..579b9a677 100644 --- a/tests/basilisp/reader_test.py +++ b/tests/basilisp/reader_test.py @@ -821,20 +821,20 @@ def test_vector(): 1.4, kw.keyword("a"), "string" ) - assert read_str_first("[\n]") == vec.PersistentVector.empty() + assert read_str_first("[\n]") == vec.EMPTY assert read_str_first("[ :a\n :b\n]") == vec.v( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("[:a :b\n]") == vec.v(kw.keyword("a"), kw.keyword("b")) assert read_str_first("[:a :b ]") == vec.v(kw.keyword("a"), kw.keyword("b")) - assert read_str_first("[\n;;comment\n]") == vec.PersistentVector.empty() + assert read_str_first("[\n;;comment\n]") == vec.EMPTY assert read_str_first("[:a :b\n;;comment\n]") == vec.v( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("[:a \n;;comment\n :b]") == vec.v( kw.keyword("a"), kw.keyword("b") ) - assert read_str_first("[\n#_[:a :b]\n]") == vec.PersistentVector.empty() + assert read_str_first("[\n#_[:a :b]\n]") == vec.EMPTY assert read_str_first("[:a :b\n#_[:a :b]\n]") == vec.v( kw.keyword("a"), kw.keyword("b") ) @@ -859,20 +859,20 @@ def test_list(): ) assert read_str_first("(- -1 2)") == llist.l(sym.symbol("-"), -1, 2) - assert read_str_first("(\n)") == llist.PersistentList.empty() + assert read_str_first("(\n)") == llist.EMPTY assert read_str_first("( :a\n :b\n)") == llist.l( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("(:a :b\n)") == llist.l(kw.keyword("a"), kw.keyword("b")) assert read_str_first("(:a :b )") == llist.l(kw.keyword("a"), kw.keyword("b")) - assert read_str_first("(\n;;comment\n)") == llist.PersistentList.empty() + assert read_str_first("(\n;;comment\n)") == llist.EMPTY assert read_str_first("(:a :b\n;;comment\n)") == llist.l( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("(:a \n;;comment\n :b)") == llist.l( kw.keyword("a"), kw.keyword("b") ) - assert read_str_first("(\n#_[:a :b]\n)") == llist.PersistentList.empty() + assert read_str_first("(\n#_[:a :b]\n)") == llist.EMPTY assert read_str_first("(:a :b\n#_[:a :b]\n)") == llist.l( kw.keyword("a"), kw.keyword("b") ) @@ -895,20 +895,20 @@ def test_set(): kw.keyword("a"), 1, "some string" ) - assert read_str_first("#{\n}") == lset.PersistentSet.empty() + assert read_str_first("#{\n}") == lset.EMPTY assert read_str_first("#{ :a\n :b\n}") == lset.s( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("#{:a :b\n}") == lset.s(kw.keyword("a"), kw.keyword("b")) assert read_str_first("#{:a :b }") == lset.s(kw.keyword("a"), kw.keyword("b")) - assert read_str_first("#{\n;;comment\n}") == lset.PersistentSet.empty() + assert read_str_first("#{\n;;comment\n}") == lset.EMPTY assert read_str_first("#{:a :b\n;;comment\n}") == lset.s( kw.keyword("a"), kw.keyword("b") ) assert read_str_first("#{:a \n;;comment\n :b}") == lset.s( kw.keyword("a"), kw.keyword("b") ) - assert read_str_first("#{\n#_[:a :b]\n}") == lset.PersistentSet.empty() + assert read_str_first("#{\n#_[:a :b]\n}") == lset.EMPTY assert read_str_first("#{:a :b\n#_[:a :b]\n}") == lset.s( kw.keyword("a"), kw.keyword("b") ) @@ -933,7 +933,7 @@ def test_map(): {kw.keyword("a"): 1, kw.keyword("b"): "string"} ) - assert read_str_first("{\n}") == lmap.PersistentMap.empty() + assert read_str_first("{\n}") == lmap.EMPTY assert read_str_first("{ :a\n :b\n}") == lmap.map( {kw.keyword("a"): kw.keyword("b")} ) @@ -941,14 +941,14 @@ def test_map(): assert read_str_first("{:a :b }") == lmap.map( {kw.keyword("a"): kw.keyword("b")} ) - assert read_str_first("{\n;;comment\n}") == lmap.PersistentMap.empty() + assert read_str_first("{\n;;comment\n}") == lmap.EMPTY assert read_str_first("{:a :b\n;;comment\n}") == lmap.map( {kw.keyword("a"): kw.keyword("b")} ) assert read_str_first("{:a \n;;comment\n :b}") == lmap.map( {kw.keyword("a"): kw.keyword("b")} ) - assert read_str_first("{\n#_[:a :b]\n}") == lmap.PersistentMap.empty() + assert read_str_first("{\n#_[:a :b]\n}") == lmap.EMPTY assert read_str_first("{:a :b\n#_[:a :b]\n}") == lmap.map( {kw.keyword("a"): kw.keyword("b")} ) @@ -1436,26 +1436,26 @@ def test_comment_reader_macro(): assert kw.keyword("kw2") == read_str_first("#_:kw1 :kw2") - assert llist.PersistentList.empty() == read_str_first("(#_sym)") + assert llist.EMPTY == read_str_first("(#_sym)") assert llist.l(sym.symbol("inc"), 5) == read_str_first("(inc #_counter 5)") assert llist.l(sym.symbol("dec"), 8) == read_str_first("(#_inc dec #_counter 8)") - assert vec.PersistentVector.empty() == read_str_first("[#_m]") + assert vec.EMPTY == read_str_first("[#_m]") assert vec.v(1) == read_str_first("[#_m 1]") assert vec.v(1) == read_str_first("[#_m 1 #_2]") assert vec.v(1, 2) == read_str_first("[#_m 1 2]") assert vec.v(1, 4) == read_str_first("[#_m 1 #_2 4]") assert vec.v(1, 4) == read_str_first("[#_m 1 #_2 4 #_5]") - assert lset.PersistentSet.empty() == read_str_first("#{#_m}") + assert lset.EMPTY == read_str_first("#{#_m}") assert lset.s(1) == read_str_first("#{#_m 1}") assert lset.s(1) == read_str_first("#{#_m 1 #_2}") assert lset.s(1, 2) == read_str_first("#{#_m 1 2}") assert lset.s(1, 4) == read_str_first("#{#_m 1 #_2 4}") assert lset.s(1, 4) == read_str_first("#{#_m 1 #_2 4 #_5}") - assert lmap.PersistentMap.empty() == read_str_first("{#_:key}") - assert lmap.PersistentMap.empty() == read_str_first('{#_:key #_"value"}') + assert lmap.EMPTY == read_str_first("{#_:key}") + assert lmap.EMPTY == read_str_first('{#_:key #_"value"}') assert lmap.map({kw.keyword("key"): "value"}) == read_str_first( '{:key #_"other" "value"}' ) @@ -1591,7 +1591,7 @@ def test_splicing_form(self): assert lset.s(1) == read_str_first("#{1 #?@(:clj [2 4 6])}") def test_splicing_form_in_maps(self): - assert lmap.PersistentMap.empty() == read_str_first("{#?@(:clj [:a 1])}") + assert lmap.EMPTY == read_str_first("{#?@(:clj [:a 1])}") assert lmap.map({kw.keyword("b"): 2}) == read_str_first( "{#?@(:clj [:a 1] :lpy [:b 2])}" ) @@ -1657,7 +1657,7 @@ def test_deref(): assert read_str_first("@s") == llist.l(reader._DEREF, sym.symbol("s")) assert read_str_first("@ns/s") == llist.l(reader._DEREF, sym.symbol("s", ns="ns")) assert read_str_first("@(atom {})") == llist.l( - reader._DEREF, llist.l(sym.symbol("atom"), lmap.PersistentMap.empty()) + reader._DEREF, llist.l(sym.symbol("atom"), lmap.EMPTY) ) diff --git a/tests/basilisp/runtime_test.py b/tests/basilisp/runtime_test.py index 1a8464c52..f736b5fda 100644 --- a/tests/basilisp/runtime_test.py +++ b/tests/basilisp/runtime_test.py @@ -146,9 +146,7 @@ def test_rest(): def test_nthrest(): assert None is runtime.nthrest(None, 1) - assert llist.PersistentList.empty() == runtime.nthrest( - llist.PersistentList.empty(), 0 - ) + assert llist.EMPTY == runtime.nthrest(llist.EMPTY, 0) assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthrest( llist.l(1, 2, 3, 4, 5, 6), 1 ) @@ -157,9 +155,7 @@ def test_nthrest(): assert lseq.sequence([5, 6]) == runtime.nthrest(llist.l(1, 2, 3, 4, 5, 6), 4) assert lseq.sequence([6]) == runtime.nthrest(llist.l(1, 2, 3, 4, 5, 6), 5) - assert vec.PersistentVector.empty() == runtime.nthrest( - vec.PersistentVector.empty(), 0 - ) + assert vec.EMPTY == runtime.nthrest(vec.EMPTY, 0) assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthrest(vec.v(1, 2, 3, 4, 5, 6), 1) assert lseq.sequence([3, 4, 5, 6]) == runtime.nthrest(vec.v(1, 2, 3, 4, 5, 6), 2) assert lseq.sequence([4, 5, 6]) == runtime.nthrest(vec.v(1, 2, 3, 4, 5, 6), 3) @@ -180,7 +176,7 @@ def test_next(): def test_nthnext(): assert None is runtime.nthnext(None, 1) - assert None is runtime.nthnext(llist.PersistentList.empty(), 0) + assert None is runtime.nthnext(llist.EMPTY, 0) assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthnext( llist.l(1, 2, 3, 4, 5, 6), 1 ) @@ -189,7 +185,7 @@ def test_nthnext(): assert lseq.sequence([5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 4) assert lseq.sequence([6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 5) - assert None is runtime.nthnext(vec.PersistentVector.empty(), 0) + assert None is runtime.nthnext(vec.EMPTY, 0) assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 1) assert lseq.sequence([3, 4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 2) assert lseq.sequence([4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 3) @@ -208,10 +204,10 @@ def test_cons(): def test_to_seq(): assert None is runtime.to_seq(None) - assert None is runtime.to_seq(llist.PersistentList.empty()) - assert None is runtime.to_seq(vec.PersistentVector.empty()) - assert None is runtime.to_seq(lmap.PersistentMap.empty()) - assert None is runtime.to_seq(lset.PersistentSet.empty()) + assert None is runtime.to_seq(llist.EMPTY) + assert None is runtime.to_seq(vec.EMPTY) + assert None is runtime.to_seq(lmap.EMPTY) + assert None is runtime.to_seq(lset.EMPTY) assert None is runtime.to_seq("") assert None is not runtime.to_seq(llist.l(None)) @@ -243,10 +239,10 @@ def test_concat(): assert lseq.EMPTY == s1 assert s1.is_empty - s1 = runtime.concat(llist.PersistentList.empty(), llist.PersistentList.empty()) + s1 = runtime.concat(llist.EMPTY, llist.EMPTY) assert lseq.EMPTY == s1 - s1 = runtime.concat(llist.PersistentList.empty(), llist.l(1, 2, 3)) + s1 = runtime.concat(llist.EMPTY, llist.l(1, 2, 3)) assert s1 == llist.l(1, 2, 3) s1 = runtime.concat(llist.l(1, 2, 3), vec.v(4, 5, 6)) @@ -355,13 +351,13 @@ def test_nth(): runtime.nth(vec.v("h", "e", "l", "l", "o"), 7) with pytest.raises(TypeError): - runtime.nth(lmap.PersistentMap.empty(), 2) + runtime.nth(lmap.EMPTY, 2) with pytest.raises(TypeError): runtime.nth(lmap.map({"a": 1, "b": 2, "c": 3}), 2) with pytest.raises(TypeError): - runtime.nth(lset.PersistentSet.empty(), 2) + runtime.nth(lset.EMPTY, 2) with pytest.raises(TypeError): runtime.nth(lset.s(1, 2, 3), 2) @@ -421,22 +417,22 @@ def test_get(): def test_assoc(): - assert lmap.PersistentMap.empty() == runtime.assoc(None) + assert lmap.EMPTY == runtime.assoc(None) assert lmap.map({"a": 1}) == runtime.assoc(None, "a", 1) assert lmap.map({"a": 8}) == runtime.assoc(lmap.map({"a": 1}), "a", 8) assert lmap.map({"a": 1, "b": "string"}) == runtime.assoc( lmap.map({"a": 1}), "b", "string" ) - assert vec.v("a") == runtime.assoc(vec.PersistentVector.empty(), 0, "a") + assert vec.v("a") == runtime.assoc(vec.EMPTY, 0, "a") assert vec.v("c", "b") == runtime.assoc(vec.v("a", "b"), 0, "c") assert vec.v("a", "c") == runtime.assoc(vec.v("a", "b"), 1, "c") with pytest.raises(IndexError): - runtime.assoc(vec.PersistentVector.empty(), 1, "a") + runtime.assoc(vec.EMPTY, 1, "a") with pytest.raises(TypeError): - runtime.assoc(llist.PersistentList.empty(), 1, "a") + runtime.assoc(llist.EMPTY, 1, "a") def test_update(): @@ -457,14 +453,14 @@ def test_update(): lmap.map({"a": 1, "b": 583}), "b", lambda _: "string" ) - assert vec.v("a") == runtime.update(vec.PersistentVector.empty(), 0, lambda _: "a") + assert vec.v("a") == runtime.update(vec.EMPTY, 0, lambda _: "a") assert vec.v("yay", "b") == runtime.update(vec.v("a", "b"), 0, lambda x: f"y{x}y") assert vec.v("a", "boy") == runtime.update( vec.v("a", "b"), 1, lambda x, y: f"{x}{y}", "oy" ) with pytest.raises(TypeError): - runtime.update(llist.PersistentList.empty(), 1, lambda _: "y") + runtime.update(llist.EMPTY, 1, lambda _: "y") def test_conj(): @@ -472,25 +468,23 @@ def test_conj(): assert llist.l(3, 2, 1) == runtime.conj(None, 1, 2, 3) assert llist.l(llist.l(1, 2, 3)) == runtime.conj(None, llist.l(1, 2, 3)) - assert llist.l(1) == runtime.conj(llist.PersistentList.empty(), 1) - assert llist.l(3, 2, 1) == runtime.conj(llist.PersistentList.empty(), 1, 2, 3) + assert llist.l(1) == runtime.conj(llist.EMPTY, 1) + assert llist.l(3, 2, 1) == runtime.conj(llist.EMPTY, 1, 2, 3) assert llist.l(3, 2, 1, 1) == runtime.conj(llist.l(1), 1, 2, 3) assert llist.l(llist.l(1, 2, 3), 1) == runtime.conj(llist.l(1), llist.l(1, 2, 3)) - assert lset.s(1) == runtime.conj(lset.PersistentSet.empty(), 1) - assert lset.s(1, 2, 3) == runtime.conj(lset.PersistentSet.empty(), 1, 2, 3) + assert lset.s(1) == runtime.conj(lset.EMPTY, 1) + assert lset.s(1, 2, 3) == runtime.conj(lset.EMPTY, 1, 2, 3) assert lset.s(1, 2, 3) == runtime.conj(lset.s(1), 1, 2, 3) assert lset.s(1, lset.s(1, 2, 3)) == runtime.conj(lset.s(1), lset.s(1, 2, 3)) - assert vec.v(1) == runtime.conj(vec.PersistentVector.empty(), 1) - assert vec.v(1, 2, 3) == runtime.conj(vec.PersistentVector.empty(), 1, 2, 3) + assert vec.v(1) == runtime.conj(vec.EMPTY, 1) + assert vec.v(1, 2, 3) == runtime.conj(vec.EMPTY, 1, 2, 3) assert vec.v(1, 1, 2, 3) == runtime.conj(vec.v(1), 1, 2, 3) assert vec.v(1, vec.v(1, 2, 3)) == runtime.conj(vec.v(1), vec.v(1, 2, 3)) - assert lmap.map({"a": 1}) == runtime.conj(lmap.PersistentMap.empty(), ["a", 1]) - assert lmap.map({"a": 1, "b": 93}) == runtime.conj( - lmap.PersistentMap.empty(), ["a", 1], ["b", 93] - ) + assert lmap.map({"a": 1}) == runtime.conj(lmap.EMPTY, ["a", 1]) + assert lmap.map({"a": 1, "b": 93}) == runtime.conj(lmap.EMPTY, ["a", 1], ["b", 93]) assert lmap.map({"a": 1, "b": 93}) == runtime.conj( lmap.map({"a": 8}), ["a", 1], ["b", 93] ) @@ -507,15 +501,13 @@ def test_conj(): def test_deref(): assert 1 == runtime.deref(atom.Atom(1)) - assert vec.PersistentVector.empty() == runtime.deref( - atom.Atom(vec.PersistentVector.empty()) - ) + assert vec.EMPTY == runtime.deref(atom.Atom(vec.EMPTY)) with pytest.raises(TypeError): runtime.deref(1) with pytest.raises(TypeError): - runtime.deref(vec.PersistentVector.empty()) + runtime.deref(vec.EMPTY) @pytest.mark.parametrize( @@ -537,28 +529,28 @@ def test_deref(): ("not empty", "not empty"), (Fraction("1/2"), Fraction("1/2")), (Decimal("3.14159"), Decimal("3.14159")), - (llist.PersistentList.empty(), llist.PersistentList.empty()), + (llist.EMPTY, llist.EMPTY), (llist.l(1, 2, 3), llist.l(1, 2, 3)), - (lmap.PersistentMap.empty(), lmap.PersistentMap.empty()), + (lmap.EMPTY, lmap.EMPTY), (lmap.map({"a": 1, "b": 2}), lmap.map({"a": 1, "b": 2})), - (lset.PersistentSet.empty(), lset.PersistentSet.empty()), - (lqueue.PersistentQueue.empty(), lqueue.PersistentQueue.empty()), + (lset.EMPTY, lset.EMPTY), + (lqueue.EMPTY, lqueue.EMPTY), (lqueue.q(1, 2, 3), lqueue.q(1, 2, 3)), (lset.s(1, 2, 3), lset.s(1, 2, 3)), - (vec.PersistentVector.empty(), vec.PersistentVector.empty()), + (vec.EMPTY, vec.EMPTY), (vec.v(1, 2, 3), vec.v(1, 2, 3)), (lseq.EMPTY, lseq.EMPTY), (lseq.EMPTY.cons(3).cons(2).cons(1), lseq.EMPTY.cons(3).cons(2).cons(1)), (lqueue.q(1, 2, 3), lseq.EMPTY.cons(3).cons(2).cons(1)), (vec.v(1, 2, 3), lseq.EMPTY.cons(3).cons(2).cons(1)), - (llist.PersistentList.empty(), vec.PersistentVector.empty()), + (llist.EMPTY, vec.EMPTY), (llist.l(1, 2, 3), vec.v(1, 2, 3)), - (lseq.EMPTY, vec.PersistentVector.empty()), + (lseq.EMPTY, vec.EMPTY), (lqueue.q(1, 2, 3), vec.v(1, 2, 3)), (lqueue.q(1, 2, 3), llist.l(1, 2, 3)), - (lseq.EMPTY, lqueue.PersistentQueue.empty()), + (lseq.EMPTY, lqueue.EMPTY), (lseq.EMPTY.cons(3).cons(2).cons(1), vec.v(1, 2, 3)), - (llist.PersistentList.empty(), lseq.EMPTY), + (llist.EMPTY, lseq.EMPTY), (lseq.EMPTY.cons(3).cons(2).cons(1), llist.l(1, 2, 3)), ], ) @@ -582,21 +574,21 @@ def test_equals(v1, v2): (lqueue.q(1, 2, 3), vec.v(2, 3, 4)), (lqueue.q(1, 2, 3), lseq.EMPTY.cons(4).cons(3).cons(2)), (vec.v(1, 2, 3), lseq.EMPTY.cons(4).cons(3).cons(2)), - (lmap.PersistentMap.empty(), llist.PersistentList.empty()), - (lmap.PersistentMap.empty(), vec.PersistentVector.empty()), - (lmap.PersistentMap.empty(), lseq.EMPTY), - (lmap.PersistentMap.empty(), lqueue.PersistentQueue.empty()), + (lmap.EMPTY, llist.EMPTY), + (lmap.EMPTY, vec.EMPTY), + (lmap.EMPTY, lseq.EMPTY), + (lmap.EMPTY, lqueue.EMPTY), (lmap.map({1: "1", 2: "2", 3: "3"}), llist.l(1, 2, 3)), (lmap.map({1: "1", 2: "2", 3: "3"}), lqueue.q(1, 2, 3)), (lmap.map({1: "1", 2: "2", 3: "3"}), vec.v(1, 2, 3)), (lmap.map({1: "1", 2: "2", 3: "3"}), lseq.EMPTY.cons(3).cons(2).cons(1)), - (lset.PersistentSet.empty(), llist.PersistentList.empty()), - (lset.PersistentSet.empty(), lmap.PersistentMap.empty()), - (lset.PersistentSet.empty(), lqueue.PersistentQueue.empty()), - (lset.PersistentSet.empty(), vec.PersistentVector.empty()), - (lset.PersistentSet.empty(), lseq.EMPTY), + (lset.EMPTY, llist.EMPTY), + (lset.EMPTY, lmap.EMPTY), + (lset.EMPTY, lqueue.EMPTY), + (lset.EMPTY, vec.EMPTY), + (lset.EMPTY, lseq.EMPTY), (lset.s(1, 2, 3), llist.l(1, 2, 3)), - (lset.s(1, 2, 3), lmap.PersistentMap.empty()), + (lset.s(1, 2, 3), lmap.EMPTY), (lset.s(1, 2, 3), lqueue.q(1, 2, 3)), (lset.s(1, 2, 3), vec.v(1, 2, 3)), (lset.s(1, 2, 3), lseq.EMPTY.cons(3).cons(2).cons(1)), @@ -624,27 +616,27 @@ def test_literal_to_py(self): assert "kw" == runtime.to_py(kw.keyword("kw", ns="kw")) def test_to_dict(self): - assert {} == runtime.to_py(lmap.PersistentMap.empty()) + assert {} == runtime.to_py(lmap.EMPTY) assert {"a": 2} == runtime.to_py(lmap.map({"a": 2})) assert {"a": 2, "b": "string"} == runtime.to_py( lmap.map({"a": 2, kw.keyword("b"): "string"}) ) def test_to_list(self): - assert [] == runtime.to_py(llist.PersistentList.empty()) + assert [] == runtime.to_py(llist.EMPTY) assert ["a", 2] == runtime.to_py(llist.l("a", 2)) assert ["a", 2, None] == runtime.to_py(llist.l("a", 2, None)) - assert [] == runtime.to_py(vec.PersistentVector.empty()) + assert [] == runtime.to_py(vec.EMPTY) assert ["a", 2] == runtime.to_py(vec.v("a", 2)) assert ["a", 2, None] == runtime.to_py(vec.v("a", 2, None)) - assert None is runtime.to_py(runtime.to_seq(vec.PersistentVector.empty())) + assert None is runtime.to_py(runtime.to_seq(vec.EMPTY)) assert ["a", 2] == runtime.to_py(runtime.to_seq(vec.v("a", 2))) assert ["a", 2, None] == runtime.to_py(runtime.to_seq(vec.v("a", 2, None))) def test_to_set(self): - assert set() == runtime.to_py(lset.PersistentSet.empty()) + assert set() == runtime.to_py(lset.EMPTY) assert {"a", 2} == runtime.to_py(lset.set({"a", 2})) assert {"a", 2, "b"} == runtime.to_py(lset.set({"a", 2, kw.keyword("b")})) @@ -661,7 +653,7 @@ def test_literal_to_lisp(self): assert kw.keyword("kw", ns="ns") == runtime.to_lisp(kw.keyword("kw", ns="ns")) def test_to_map(self): - assert lmap.PersistentMap.empty() == runtime.to_lisp({}) + assert lmap.EMPTY == runtime.to_lisp({}) assert lmap.map({kw.keyword("a"): 2}) == runtime.to_lisp({"a": 2}) assert lmap.map( {kw.keyword("a"): 2, kw.keyword("b"): "string"} @@ -691,7 +683,7 @@ def test_to_map(self): ) def test_to_map_no_keywordize(self): - assert lmap.PersistentMap.empty() == runtime.to_lisp({}) + assert lmap.EMPTY == runtime.to_lisp({}) assert lmap.map({"a": 2}) == runtime.to_lisp({"a": 2}, keywordize_keys=False) assert lmap.map({"a": 2, "b": "string"}) == runtime.to_lisp( {"a": 2, "b": "string"}, keywordize_keys=False @@ -722,20 +714,18 @@ def test_to_map_no_keywordize(self): ) def test_to_set(self): - assert lset.PersistentSet.empty() == runtime.to_lisp(set()) + assert lset.EMPTY == runtime.to_lisp(set()) assert lset.set({"a", 2}) == runtime.to_lisp({"a", 2}) assert lset.set({"a", 2, kw.keyword("b")}) == runtime.to_lisp( {"a", 2, kw.keyword("b")} ) def test_to_vec(self): - assert vec.PersistentVector.empty() == runtime.to_lisp([]) + assert vec.EMPTY == runtime.to_lisp([]) assert vec.v("a", 2) == runtime.to_lisp(["a", 2]) assert vec.v("a", 2, None) == runtime.to_lisp(["a", 2, None]) - assert vec.PersistentVector.empty() == runtime.to_lisp( - vec.PersistentVector.empty() - ) + assert vec.EMPTY == runtime.to_lisp(vec.EMPTY) assert vec.v("a", 2) == runtime.to_lisp(("a", 2)) assert vec.v("a", 2, None) == runtime.to_lisp(("a", 2, None)) diff --git a/tests/basilisp/seq_test.py b/tests/basilisp/seq_test.py index 130b54683..a85e3f5e7 100644 --- a/tests/basilisp/seq_test.py +++ b/tests/basilisp/seq_test.py @@ -117,7 +117,7 @@ def test_sequence(): def test_seq_iterator(): s = lseq.sequence([]) - assert vec.PersistentVector.empty() == vec.vector(s) + assert vec.EMPTY == vec.vector(s) s = lseq.sequence(range(10000)) assert 10000 == len(vec.vector(s)) diff --git a/tests/basilisp/set_test.py b/tests/basilisp/set_test.py index 633b75ffc..91bef37f2 100644 --- a/tests/basilisp/set_test.py +++ b/tests/basilisp/set_test.py @@ -43,7 +43,7 @@ def test_set_as_function(): def test_set_bool(): - assert True is bool(lset.PersistentSet.empty()) + assert True is bool(lset.EMPTY) def test_set_conj(): @@ -57,6 +57,30 @@ def test_set_conj(): assert meta == s2.meta +def test_set_disj(): + meta = lmap.m(tag="async") + s1 = lset.s(keyword("kw1"), keyword("kw2"), meta=meta) + s2 = s1.disj(keyword("kw2")) + s3 = s2.disj(keyword("kw1")) + assert s1 is not s2 + assert s2 is not s3 + assert s1 != s2 + assert s2 != s3 + assert len(s2) == 1 + assert len(s3) == 0 + assert meta == s1.meta + assert meta == s2.meta + assert meta == s3.meta + + +def test_set_empty(): + meta = lmap.map({"meta": 1}) + s1 = lset.s(1, 2, 3, meta=meta) + assert s1.empty() == lset.EMPTY + assert s1.empty().meta == meta + assert lset.EMPTY.meta is None + + def test_set_meta(): assert lset.s("vec").meta is None meta = lmap.m(type=symbol("str")) @@ -85,7 +109,7 @@ def test_set_with_meta(): def test_set_seq(): - assert None is lset.PersistentSet.empty().seq() + assert None is lset.EMPTY.seq() assert {1} == set(lset.s(1).seq()) assert {1, 2} == set(lset.s(1, 2).seq()) assert {1, 2, 3} == set(lset.s(1, 2, 3).seq()) diff --git a/tests/basilisp/vector_test.py b/tests/basilisp/vector_test.py index 89c817f99..dadcb8998 100644 --- a/tests/basilisp/vector_test.py +++ b/tests/basilisp/vector_test.py @@ -52,18 +52,29 @@ def test_vector_slice(): def test_assoc(): - v = vec.PersistentVector.empty() + v = vec.EMPTY assert vec.v("a") == v.assoc(0, "a") - assert vec.PersistentVector.empty() == v + assert vec.EMPTY == v assert vec.vector(["a", "b"]) == v.assoc(0, "a", 1, "b") - v1 = vec.v("a") + meta = lmap.m(meta=True) + v1 = vec.v("a", meta=meta) assert vec.v("c", "b") == v1.assoc(0, "c", 1, "b") assert vec.v("a", "b") == v1.assoc(1, "b") + assert v1.assoc(1, "b").meta == meta + assert v1.assoc(1, "b", 2, "c").meta == meta + + +def test_vector_empty(): + meta = lmap.map({"meta": 1}) + v1 = vec.v(1, 2, 3, meta=meta) + assert v1.empty() == vec.EMPTY + assert v1.empty().meta == meta + assert vec.EMPTY.meta is None def test_vector_bool(): - assert True is bool(vec.PersistentVector.empty()) + assert True is bool(vec.EMPTY) def test_contains(): @@ -71,16 +82,16 @@ def test_contains(): assert True is vec.v("a", "b").contains(1) assert False is vec.v("a", "b").contains(2) assert False is vec.v("a", "b").contains(-1) - assert False is vec.PersistentVector.empty().contains(0) - assert False is vec.PersistentVector.empty().contains(1) - assert False is vec.PersistentVector.empty().contains(-1) + assert False is vec.EMPTY.contains(0) + assert False is vec.EMPTY.contains(1) + assert False is vec.EMPTY.contains(-1) def test_py_contains(): assert "a" in vec.v("a") assert "a" in vec.v("a", "b") assert "b" in vec.v("a", "b") - assert "c" not in vec.PersistentVector.empty() + assert "c" not in vec.EMPTY assert "c" not in vec.v("a") assert "c" not in vec.v("a", "b") @@ -101,9 +112,9 @@ def test_entry(): assert vec.MapEntry.of(1, "b") == vec.v("a", "b").entry(1) assert None is vec.v("a", "b").entry(2) assert vec.MapEntry.of(-1, "b") == vec.v("a", "b").entry(-1) - assert None is vec.PersistentVector.empty().entry(0) - assert None is vec.PersistentVector.empty().entry(1) - assert None is vec.PersistentVector.empty().entry(-1) + assert None is vec.EMPTY.entry(0) + assert None is vec.EMPTY.entry(1) + assert None is vec.EMPTY.entry(-1) def test_vector_callable(): @@ -111,9 +122,9 @@ def test_vector_callable(): assert "b" == vec.v("a", "b")(1) assert None is vec.v("a", "b")(2) assert "b" == vec.v("a", "b")(-1) - assert None is vec.PersistentVector.empty()(0) - assert None is vec.PersistentVector.empty()(1) - assert None is vec.PersistentVector.empty()(-1) + assert None is vec.EMPTY(0) + assert None is vec.EMPTY(1) + assert None is vec.EMPTY(-1) def test_val_at(): @@ -121,13 +132,13 @@ def test_val_at(): assert "b" == vec.v("a", "b").val_at(1) assert None is vec.v("a", "b").val_at(2) assert "b" == vec.v("a", "b").val_at(-1) - assert None is vec.PersistentVector.empty().val_at(0) - assert None is vec.PersistentVector.empty().val_at(1) - assert None is vec.PersistentVector.empty().val_at(-1) - assert None is vec.PersistentVector.empty().val_at(keyword("blah")) - assert "default" == vec.PersistentVector.empty().val_at(keyword("blah"), "default") - assert None is vec.PersistentVector.empty().val_at("key") - assert "default" == vec.PersistentVector.empty().val_at("key", "default") + assert None is vec.EMPTY.val_at(0) + assert None is vec.EMPTY.val_at(1) + assert None is vec.EMPTY.val_at(-1) + assert None is vec.EMPTY.val_at(keyword("blah")) + assert "default" == vec.EMPTY.val_at(keyword("blah"), "default") + assert None is vec.EMPTY.val_at("key") + assert "default" == vec.EMPTY.val_at("key", "default") def test_peek(): @@ -142,13 +153,13 @@ def test_pop(): with pytest.raises(IndexError): vec.v().pop() - assert vec.PersistentVector.empty() == vec.v(1).pop() + assert vec.EMPTY == vec.v(1).pop() assert vec.v(1) == vec.v(1, 2).pop() assert vec.v(1, 2) == vec.v(1, 2, 3).pop() def test_vector_seq(): - assert None is vec.PersistentVector.empty().seq() + assert None is vec.EMPTY.seq() assert vec.v(1) == vec.v(1).seq() assert vec.v(1, 2) == vec.v(1, 2).seq() assert vec.v(1, 2, 3) == vec.v(1, 2, 3).seq()