def test_seq_take(xs: List[int], x: int):
ys = seq.of_iterable(xs)
try:
zs = pipe(ys, seq.take(x))
assert list(zs) == xs[:x]
except ValueError:
assert x > len(xs)
def test_seq_pipeline(xs: List[int]):
mapper: Callable[[int], int] = lambda x: x * 10
predicate: Callable[[int], bool] = lambda x: x > 100
folder: Callable[[int, int], int] = lambda s, x: s + x
ys = seq.of_iterable(xs).pipe(
seq.map(mapper),
seq.filter(predicate),
seq.fold(folder, 0),
)
assert ys == functools.reduce(
lambda s, x: s + x, filter(lambda x: x > 100,
map(lambda x: x * 10, xs)), 0)
def test_seq_fold_pipe(xs: List[int], s: int):
folder: Callable[[int, int], int] = lambda s, v: s + v
value = pipe(seq.of_iterable(xs), seq.fold(folder, s))
assert value == sum(xs) + s
def test_seq_head_fluent(xs: List[int]):
value = seq.of_iterable(xs).head()
assert value == xs[0]
def test_seq_scan_fluent(xs: List[int], s: int):
func: Callable[[int, int], int] = lambda s, v: s + v
value = seq.of_iterable(xs).scan(func, s)
assert list(value) == list(accumulate(xs, func, initial=s))
def test_seq_fold_fluent(xs: List[int], s: int):
value = seq.of_iterable(xs).fold(lambda s, v: s + v, s)
assert value == sum(xs) + s
def test_seq_len(xs: List[int]):
ys = seq.of_iterable(xs)
n = ys.length()
assert n == len(xs)
def test_seq_length(xs: List[int]):
ys = seq.of_iterable(xs)
n = pipe(ys, seq.length)
assert n == len(xs)
def test_seq_scan_pipe(xs: List[int], s: int):
func: Callable[[int, int], int] = lambda s, v: s + v
value = pipe(seq.of_iterable(xs), seq.scan(func, s))
expected: Iterable[int] = accumulate(xs, func, initial=s)
assert list(value) == list(expected)
