def test_seq_equals():
# to_seq should be first to ensure that `ISeq.__eq__` is used
assert runtime.to_seq(vec.v(1, 2, 3)) == llist.l(1, 2, 3)
assert False is (runtime.to_seq(vec.v(1, 2, 3)) == kw.keyword("abc"))
assert lseq.sequence(vec.v(1, 2, 3)) == llist.l(1, 2, 3)
assert False is (lseq.sequence(vec.v(1, 2, 3)) == kw.keyword("abc"))
def test_empty_sequence():
empty = lseq.sequence([])
assert empty.is_empty
assert None is empty.first
assert empty.rest == empty
assert llist.l(1) == empty.cons(1)
assert lseq.EMPTY is empty
assert True is bool(lseq.sequence([]))
def test_to_sequence():
assert lseq.EMPTY is lseq.sequence([])
assert lseq.sequence([]).is_empty
assert llist.l(None) == lseq.sequence([None])
assert not lseq.sequence([None]).is_empty
assert llist.l(1) == lseq.sequence([1])
assert not lseq.sequence([1]).is_empty
assert llist.l(1, 2, 3) == lseq.sequence([1, 2, 3])
assert not lseq.sequence([1, 2, 3]).is_empty
def test_nthnext():
assert None is runtime.nthnext(None, 1)
assert None is runtime.nthnext(llist.PersistentList.empty(), 0)
assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthnext(
llist.l(1, 2, 3, 4, 5, 6), 1
)
assert lseq.sequence([3, 4, 5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 2)
assert lseq.sequence([4, 5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 3)
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 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)
assert lseq.sequence([5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 4)
assert lseq.sequence([6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 5)
def test_lazy_sequence():
s = lseq.LazySeq(lambda: None)
assert s.is_empty
assert None is s.first
assert lseq.EMPTY is s.rest
assert s.is_realized
assert s.is_empty, "LazySeq has been realized and is empty"
s = lseq.LazySeq(lambda: lseq.EMPTY)
assert s.is_empty
assert None is s.first
assert lseq.EMPTY is s.rest
assert s.is_realized
assert s.is_empty, "LazySeq has been realized and is empty"
s = lseq.LazySeq(lambda: lseq.sequence([1]))
assert not s.is_empty
assert 1 == s.first
assert lseq.EMPTY is s.rest
assert s.is_realized
assert not s.is_empty, "LazySeq has been realized and is not empty"
def lazy_seq():
def inner_seq():
def inner_inner_seq():
return lseq.sequence([3])
return lseq.LazySeq(inner_inner_seq).cons(2)
return lseq.LazySeq(inner_seq).cons(1)
s = lseq.LazySeq(lazy_seq)
assert not s.is_empty
assert 1 == s.first
assert isinstance(s.rest, lseq.LazySeq)
assert s.is_realized
assert not s.is_empty, "LazySeq has been realized and is not empty"
r = s.rest
assert not r.is_empty
assert 2 == r.first
assert isinstance(r.rest, lseq.LazySeq)
assert r.is_realized
assert not r.is_empty, "LazySeq has been realized and is not empty"
t = r.rest
assert not t.is_empty
assert 3 == t.first
assert lseq.EMPTY is t.rest
assert t.is_realized
assert not t.is_empty, "LazySeq has been realized and is not empty"
assert [1, 2, 3] == [e for e in s]
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_sequence():
s = lseq.sequence([1])
assert not s.is_empty
assert 1 == s.first
assert lseq.EMPTY is s.rest
assert llist.l(2, 1) == s.cons(2)
assert [1, 2, 3] == [e for e in lseq.sequence([1, 2, 3])]
assert llist.l(1, 2, 3) == lseq.sequence([1, 2, 3])
assert llist.l(1, 2, 3) == lseq.sequence(llist.l(1, 2, 3))
assert llist.l(1, 2, 3) == llist.list(lseq.sequence([1, 2, 3]))
s = lseq.sequence([1, 2, 3])
assert not s.is_empty
assert 2 == s.rest.first
assert 3 == s.rest.rest.first
assert None is s.rest.rest.rest.first
def seq(self) -> Optional[ISeq[IMapEntry[K, V]]]:
if len(self._inner) == 0:
return None
return sequence(MapEntry.of(k, v) for k, v in self._inner.items())
def seq(self) -> Optional[ISeq[T]]:
if len(self._inner) == 0:
return None
return sequence(self)
def rseq(self) -> ISeq[T]:
return sequence(reversed(self))
def seq(self) -> Optional[ISeq[T]]: # type: ignore[override]
if len(self._inner) == 0:
return None
return sequence(self)
def inner_inner_seq():
return lseq.sequence([3])
def test_seq_iterator():
s = lseq.sequence([])
assert vec.PersistentVector.empty() == vec.vector(s)
s = lseq.sequence(range(10000))
assert 10000 == len(vec.vector(s))