def test_hash_map_creator(): assert lmap.m() == lmap.hash_map() assert lmap.map({1: 2}) == lmap.hash_map(1, 2) assert lmap.map({1: 2, 3: 4}) == lmap.hash_map(1, 2, 3, 4) with pytest.raises(IndexError): lmap.hash_map(1, 2, 3)
def test_update(): assert lmap.map({"a": 1}) == runtime.update(None, "a", lambda _: 1) assert lmap.map({"a": 50}) == runtime.update(None, "a", lambda _, x: x, 50) assert lmap.map({"a": 2}) == runtime.update( lmap.map({"a": 1}), "a", lambda x: x + 1 ) assert lmap.map({"a": 4}) == runtime.update( lmap.map({"a": 1}), "a", lambda x, y: x * y + 1, 3 ) assert lmap.map({"a": 1, "b": "string"}) == runtime.update( lmap.map({"a": 1}), "b", lambda _: "string" ) assert lmap.map({"a": 1, "b": "string"}) == runtime.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("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")
def test_keyword_as_function(): kw = keyword("kw") assert None is kw(None) assert 1 == kw(lmap.map({kw: 1})) assert "hi" == kw(lmap.map({kw: "hi"})) assert None is kw(lmap.map({"hi": kw}))
def test_map_cons(): meta = lmap.m(tag="async") m1 = lmap.map({"first": "Chris"}, meta=meta) m2 = m1.cons({"last": "Cronk"}) assert m1 is not m2 assert m1 != m2 assert len(m2) == 2 assert meta == m1.meta assert meta == m2.meta assert "Chris" == m1.get("first") assert not m1.contains("last") assert "Cronk" == m2.get("last") assert "Chris" == m2.get("first") meta = lmap.m(tag="async") m1 = lmap.map({"first": "Chris"}, meta=meta) m2 = m1.cons(MapEntry.of("last", "Cronk")) assert m1 is not m2 assert m1 != m2 assert len(m2) == 2 assert meta == m1.meta assert meta == m2.meta assert "Chris" == m1.get("first") assert not m1.contains("last") assert "Cronk" == m2.get("last") assert "Chris" == m2.get("first") meta = lmap.m(tag="async") m1 = lmap.map({"first": "Chris"}, meta=meta) m2 = m1.cons(["last", "Cronk"]) assert m1 is not m2 assert m1 != m2 assert len(m2) == 2 assert meta == m1.meta assert meta == m2.meta assert "Chris" == m1.get("first") assert not m1.contains("last") assert "Cronk" == m2.get("last") assert "Chris" == m2.get("first") meta = lmap.m(tag="async") m1 = lmap.map({"first": "Chris"}, meta=meta) m2 = m1.cons(["last", "Cronk"], v("middle", "L")) assert m1 is not m2 assert m1 != m2 assert len(m2) == 3 assert meta == m1.meta assert meta == m2.meta assert "Chris" == m1.get("first") assert not m1.contains("middle") assert not m1.contains("last") assert "Cronk" == m2.get("last") assert "L" == m2.get("middle") assert "Chris" == m2.get("first") with pytest.raises(ValueError): m1 = lmap.map({"first": "Chris"}) m1.cons(["last"])
def test_assoc(): m = lmap.m() assert lmap.map({"k": 1}) == m.assoc("k", 1) assert lmap.PersistentMap.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)
def test_map_repr(): m = lmap.m() assert repr(m) == "{}" m = lmap.map({keyword("key"): "val"}) assert repr(m) == '{:key "val"}' m = lmap.map({keyword("key1"): "val1", keyword("key2"): 3}) assert repr(m) in ['{:key2 3 :key1 "val1"}', '{:key1 "val1" :key2 3}']
def test_map_seq(): assert None is lmap.PersistentMap.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(lmap.map({ "a": 1, "b": 2, "c": 3 }).seq())
def test_dissoc(): assert lmap.PersistentMap.empty() == lmap.PersistentMap.empty().dissoc("a") assert lmap.PersistentMap.empty() == lmap.PersistentMap.empty().dissoc( "a", "b", "c") m1 = lmap.map({"a": 3}) assert m1 == m1.dissoc("b") assert lmap.PersistentMap.empty() == m1.dissoc("a") m2 = lmap.map({"a": 3, "b": 2}) assert lmap.map({"a": 3}) == m2.dissoc("b") assert lmap.map({"b": 2}) == m2.dissoc("a") assert lmap.PersistentMap.empty() == m2.dissoc("a", "b")
def ns(self) -> Namespace: ns_sym = sym.symbol("test") ns = Namespace(ns_sym) str_ns_alias = sym.symbol("basilisp.string") join_sym = sym.symbol("join") chars_sym = sym.symbol("chars") str_ns = Namespace(str_ns_alias) str_ns.intern(join_sym, Var(ns, join_sym)) str_ns.intern( chars_sym, Var(ns, chars_sym, meta=lmap.map({kw.keyword("private"): True}))) ns.add_alias(str_ns, str_ns_alias) str_alias = sym.symbol("str") ns.add_alias(Namespace(str_alias), str_alias) str_sym = sym.symbol("str") ns.intern(str_sym, Var(ns, str_sym)) is_string_sym = sym.symbol("string?") ns.intern(is_string_sym, Var(ns, is_string_sym)) time_sym = sym.symbol("time") time_alias = sym.symbol("py-time") ns.add_import(time_sym, __import__("time"), time_alias) core_ns = Namespace(sym.symbol("basilisp.core")) map_alias = sym.symbol("map") ns.add_refer(map_alias, Var(core_ns, map_alias)) return ns
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("") 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})) assert None is not runtime.to_seq(lset.s(1)) assert None is not runtime.to_seq("string") one_elem = llist.l(kw.keyword("kw")) assert one_elem == runtime.to_seq(one_elem) seqable = vec.v(kw.keyword("kw")) assert seqable == runtime.to_seq(seqable) v1 = vec.v(kw.keyword("kw"), 1, llist.l("something"), 3) s1 = runtime.to_seq(v1) assert isinstance(s1, ISeq) for v, s in zip(v1, s1): assert v == s py_list = [1, 2, 3] assert llist.l(1, 2, 3) == runtime.to_seq(py_list)
def test_refer_all(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym1, var_val1 = sym.symbol("useful-value"), "cool string" var1 = Var(ns1, var_sym1) var1.set_value(var_val1) ns1.intern(var_sym1, var1) var_sym2, var_val2 = sym.symbol("private-value"), "private string" var2 = Var(ns1, var_sym2, meta=lmap.map({kw.keyword("private"): True})) var2.set_value(var_val2) ns1.intern(var_sym2, var2) var_sym3, var_val3 = sym.symbol("existing-value"), "interned string" var3 = Var(ns1, var_sym3) var3.set_value(var_val3) ns1.intern(var_sym3, var3) ns2 = get_or_create_ns(sym.symbol("ns2")) var_val4 = "some other value" var4 = Var(ns2, var_sym3) var4.set_value(var_val4) ns2.intern(var_sym3, var4) ns2.refer_all(ns1) assert var1 is ns2.get_refer(var_sym1) assert var1 is ns2.find(var_sym1) assert var_val1 == ns2.find(var_sym1).value assert None is ns2.get_refer(var_sym2) assert None is ns2.find(var_sym2) assert var3 is ns2.get_refer(var_sym3) assert var4 is ns2.find(var_sym3) assert var_val4 == ns2.find(var_sym3).value
def ns_cache(core_ns_sym: sym.Symbol, core_ns: Namespace) -> atom.Atom[NamespaceMap]: """Patch the Namespace cache with a test fixture.""" with patch( "basilisp.lang.runtime.Namespace._NAMESPACES", new=atom.Atom(lmap.map({core_ns_sym: core_ns})), ) as cache: yield cache
def test_assoc(): assert lmap.PersistentMap.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("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") with pytest.raises(TypeError): runtime.assoc(llist.PersistentList.empty(), 1, "a")
def test_reset_atom_meta(): a = atom.Atom(None) assert a.meta is None a.reset_meta(lmap.map({"type": sym.symbol("str")})) assert a.meta == lmap.m(type=sym.symbol("str")) a.reset_meta(lmap.m(tag=kw.keyword("async"))) assert a.meta == lmap.m(tag=kw.keyword("async"))
def test_private_var( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val, meta=lmap.map({kw.keyword("private"): True})) assert v.is_private
def test_multi_function(): def dispatch(v) -> kw.Keyword: if v == "i": return kw.keyword("a") elif v == "ii": return kw.keyword("b") return kw.keyword("default") def fn_a(v) -> str: return "1" def fn_b(v) -> str: return "2" def fn_default(v) -> str: return "BLAH" f = multifn.MultiFunction(sym.symbol("test-fn"), dispatch, kw.keyword("default")) f.add_method(kw.keyword("a"), fn_a) f.add_method(kw.keyword("b"), fn_b) f.add_method(kw.keyword("default"), fn_default) assert (lmap.map({ kw.keyword("a"): fn_a, kw.keyword("b"): fn_b, kw.keyword("default"): fn_default, }) == f.methods) assert kw.keyword("default") == f.default assert fn_a is f.get_method(kw.keyword("a")) assert fn_b is f.get_method(kw.keyword("b")) assert fn_default is f.get_method(kw.keyword("default")) assert fn_default is f.get_method(kw.keyword("other")) assert "1" == f("i") assert "2" == f("ii") assert "BLAH" == f("iii") assert "BLAH" == f("whatever") f.remove_method(kw.keyword("b")) assert "1" == f("i") assert "BLAH" == f("ii") assert "BLAH" == f("iii") assert "BLAH" == f("whatever") f.remove_all_methods() assert lmap.PersistentMap.empty() == f.methods with pytest.raises(NotImplementedError): f("blah")
def test_reset_ns_meta( ns_cache: atom.Atom[NamespaceMap], ns_sym: sym.Symbol, ): ns = get_or_create_ns(ns_sym) assert ns.meta is None ns.reset_meta(lmap.map({"type": sym.symbol("str")})) assert ns.meta == lmap.m(type=sym.symbol("str")) ns.reset_meta(lmap.m(tag=kw.keyword("async"))) assert ns.meta == lmap.m(tag=kw.keyword("async"))
def ns_cache_with_existing_ns(ns_sym: sym.Symbol, core_ns_sym: sym.Symbol, core_ns: Namespace) -> atom.Atom[NamespaceMap]: """Patch the Namespace cache with a test fixture with an existing namespace.""" with patch( "basilisp.lang.runtime.Namespace._NAMESPACES", atom.Atom( lmap.map({ core_ns_sym: core_ns, ns_sym: Namespace(ns_sym) })), ) as cache: yield cache
def test_cannot_refer_private(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym, var_val = sym.symbol("useful-value"), "cool string" var = Var(ns1, var_sym, meta=lmap.map({kw.keyword("private"): True})) var.set_value(var_val) ns1.intern(var_sym, var) ns2 = get_or_create_ns(sym.symbol("ns2")) ns2.add_refer(var_sym, var) assert None is ns2.get_refer(var_sym) assert None is ns2.find(var_sym)
def test_reset_var_meta( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val) assert v.meta is None v.reset_meta(lmap.map({"type": sym.symbol("str")})) assert v.meta == lmap.m(type=sym.symbol("str")) v.reset_meta(lmap.m(tag=kw.keyword("async"))) assert v.meta == lmap.m(tag=kw.keyword("async"))
def test_conj(): assert llist.l(1) == runtime.conj(None, 1) 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(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, 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, 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, "b": 93}) == runtime.conj( lmap.map({"a": 8}), ["a", 1], ["b", 93] ) with pytest.raises(ValueError): runtime.conj(lmap.map({"a": 8}), "a", 1, "b", 93) with pytest.raises(TypeError): runtime.conj(3, 1, "a") with pytest.raises(TypeError): runtime.conj("b", 1, "a")
def test_intern( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): meta = lmap.map({kw.keyword("hello"): "there"}) v = Var.intern(ns_sym, var_name, intern_val, meta=meta) assert isinstance(v, Var) assert ns_sym.name == v.ns.name assert var_name == v.name assert v.is_bound assert not v.dynamic assert not v.is_thread_bound assert intern_val == v.root assert intern_val == v.value assert intern_val == v.deref() assert meta == v.meta ns = get_or_create_ns(ns_sym) assert None is not ns assert ns.find(var_name) == v # Check that attempting to re-intern the Var will overwrite meta and dynamic new_meta = lmap.map({kw.keyword("general"): "kenobi"}) new_value = kw.keyword("new-value") re_v = Var.intern(ns_sym, var_name, new_value, dynamic=True, meta=new_meta) assert v is re_v assert ns_sym.name == v.ns.name assert var_name == v.name assert v.is_bound assert v.dynamic assert not v.is_thread_bound assert new_value == v.root assert new_value == v.value assert new_value == v.deref() assert new_meta == v.meta
def _validate(self, val: Any, vf: Optional[RefValidator] = None): vf = vf or self._validator if vf is not None: try: res = vf(val) except Exception: res = False if not res: raise ExceptionInfo( "Invalid reference state", lmap.map({ kw.keyword("data"): val, kw.keyword("validator"): vf }), )
def test_map_with_meta(): m1 = lmap.m(key1="vec") assert m1.meta is None meta1 = lmap.m(type=symbol("str")) m2 = lmap.map({"key1": "vec"}, meta=meta1) assert m2.meta == meta1 meta2 = lmap.m(tag=keyword("async")) m3 = m2.with_meta(meta2) assert m2 is not m3 assert m2 == m3 assert m3.meta == lmap.m(tag=keyword("async")) meta3 = lmap.m(tag=keyword("macro")) m4 = m3.with_meta(meta3) assert m3 is not m4 assert m3 == m4 assert m4.meta == lmap.m(tag=keyword("macro"))
def data(self) -> IPersistentMap: d: Dict[kw.Keyword, Any] = {_PHASE: self.phase.value} loc = None if self.form is not None: d[_FORM] = self.form loc = (_loc( self.form.meta.val_at(READER_LINE_KW), self.form.meta.val_at(READER_COL_KW), ) if isinstance(self.form, IMeta) and self.form.meta else None) if self.lisp_ast is not None: # pragma: no cover d[_LISP_AST] = self.lisp_ast loc = loc or _loc(self.lisp_ast.env.line, self.lisp_ast.env.col) if self.py_ast is not None: # pragma: no cover d[_PY_AST] = self.py_ast loc = loc or _loc(self.py_ast.lineno, self.py_ast.col_offset) if loc: # pragma: no cover d[_LINE] = loc.line d[_COL] = loc.col return lmap.map(d)
def compiler_opts( # pylint: disable=too-many-arguments warn_on_shadowed_name: Optional[bool] = None, warn_on_shadowed_var: Optional[bool] = None, warn_on_unused_names: Optional[bool] = None, warn_on_non_dynamic_set: Optional[bool] = None, use_var_indirection: Optional[bool] = None, warn_on_var_indirection: Optional[bool] = None, ) -> CompilerOpts: """Return a map of compiler options with defaults applied.""" return lmap.map( { # Analyzer options WARN_ON_SHADOWED_NAME: warn_on_shadowed_name or False, WARN_ON_SHADOWED_VAR: warn_on_shadowed_var or False, WARN_ON_UNUSED_NAMES: warn_on_unused_names or True, WARN_ON_NON_DYNAMIC_SET: warn_on_non_dynamic_set or True, # Generator options USE_VAR_INDIRECTION: use_var_indirection or False, WARN_ON_VAR_INDIRECTION: warn_on_var_indirection or True, } )
def test_nth(): assert None is runtime.nth(None, 1) assert "not found" == runtime.nth(None, 4, "not found") assert "l" == runtime.nth("hello world", 2) assert "l" == runtime.nth(["h", "e", "l", "l", "o"], 2) assert "l" == runtime.nth(llist.l("h", "e", "l", "l", "o"), 2) assert "l" == runtime.nth(vec.v("h", "e", "l", "l", "o"), 2) assert "l" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 2) assert "Z" == runtime.nth(llist.l("h", "e", "l", "l", "o"), 7, "Z") assert "Z" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 7, "Z") assert "Z" == runtime.nth(vec.v("h", "e", "l", "l", "o"), 7, "Z") with pytest.raises(IndexError): runtime.nth(llist.l("h", "e", "l", "l", "o"), 7) with pytest.raises(IndexError): runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 7) with pytest.raises(IndexError): runtime.nth(vec.v("h", "e", "l", "l", "o"), 7) with pytest.raises(TypeError): runtime.nth(lmap.PersistentMap.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) with pytest.raises(TypeError): runtime.nth(lset.s(1, 2, 3), 2) with pytest.raises(TypeError): runtime.nth(3, 1) with pytest.raises(TypeError): runtime.nth(3, 1, "Z")
def test_get(): assert None is runtime.get(None, "a") assert kw.keyword("nada") is runtime.get(None, "a", kw.keyword("nada")) assert None is runtime.get(3, "a") assert kw.keyword("nada") is runtime.get(3, "a", kw.keyword("nada")) assert 1 == runtime.get(lmap.map({"a": 1}), "a") assert None is runtime.get(lmap.map({"a": 1}), "b") assert 2 == runtime.get(lmap.map({"a": 1}), "b", 2) assert 1 == runtime.get(lmap.map({"a": 1}).to_transient(), "a") assert None is runtime.get(lmap.map({"a": 1}).to_transient(), "b") assert 2 == runtime.get(lmap.map({"a": 1}).to_transient(), "b", 2) assert 1 == runtime.get(vec.v(1, 2, 3), 0) assert None is runtime.get(vec.v(1, 2, 3), 3) assert "nada" == runtime.get(vec.v(1, 2, 3), 3, "nada") assert 1 == runtime.get(vec.v(1, 2, 3).to_transient(), 0) assert None is runtime.get(vec.v(1, 2, 3).to_transient(), 3) assert "nada" == runtime.get(vec.v(1, 2, 3).to_transient(), 3, "nada") assert "l" == runtime.get("hello world", 2) assert None is runtime.get("hello world", 50) assert "nada" == runtime.get("hello world", 50, "nada") assert "l" == runtime.get(["h", "e", "l", "l", "o"], 2) assert None is runtime.get(["h", "e", "l", "l", "o"], 50) assert "nada" == runtime.get(["h", "e", "l", "l", "o"], 50, "nada") assert 1 == runtime.get({"a": 1}, "a") assert None is runtime.get({"a": 1}, "b") assert 2 == runtime.get({"a": 1}, "b", 2) assert "a" == runtime.get({"a", "b", "c"}, "a") assert None is runtime.get({"a", "b", "c"}, "d") assert 2 == runtime.get({"a", "b", "c"}, "d", 2) assert "a" == runtime.get(frozenset({"a", "b", "c"}), "a") assert None is runtime.get(frozenset({"a", "b", "c"}), "d") assert 2 == runtime.get(frozenset({"a", "b", "c"}), "d", 2) assert "a" == runtime.get(lset.set({"a", "b", "c"}), "a") assert None is runtime.get(lset.set({"a", "b", "c"}), "d") assert 2 == runtime.get(lset.set({"a", "b", "c"}), "d", 2) assert "a" == runtime.get(lset.set({"a", "b", "c"}).to_transient(), "a") assert None is runtime.get(lset.set({"a", "b", "c"}).to_transient(), "d") assert 2 == runtime.get(lset.set({"a", "b", "c"}).to_transient(), "d", 2) # lists are "supported" by virtue of the fact that `get`-ing them does not fail assert None is runtime.get(llist.l(1, 2, 3), 0) assert None is runtime.get(llist.l(1, 2, 3), 3) assert "nada" == runtime.get(llist.l(1, 2, 3), 0, "nada")
def ns_cache(ns_sym: sym.Symbol) -> atom.Atom[NamespaceMap]: with patch( "basilisp.lang.runtime.Namespace._NAMESPACES", atom.Atom(lmap.map({ns_sym: Namespace(ns_sym)})), ) as ns_cache: yield ns_cache
def test_to_map_no_keywordize(self): assert lmap.PersistentMap.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 )