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
)
