superleaf.sequences.serial#

Functions

filtered(f, seq)

Return list(filter(f, seq)).

flatmap(f, seq[, depth, drop_null])

Map f over seq and flatten the results.

flatten(seq[, depth, drop_null])

Flatten nested sequences into a list.

groupby(f, seq)

Group items by key.

mapped(f, seq)

Return list(map(f, seq)).

partitioned(f, seq)

Split items by a predicate.
superleaf.sequences.serial.mapped(f: Callable[[T], U], seq: Iterable[T]) → list[U][source]#

Return list(map(f, seq)).

Parameters:

  • f (callable) – Function applied to each item.

  • seq (iterable) – Items.

Returns:

Results in input order.

Return type:

list[U]

superleaf.sequences.serial.filtered(f: Callable[[T], bool], seq: Iterable[T]) → list[T][source]#

Return list(filter(f, seq)).

Parameters:

  • f (callable) – Predicate.

  • seq (iterable) – Items.

Returns:

Items for which f is truthy, in input order.

Return type:

list[T]

superleaf.sequences.serial.groupby(f: Callable[[T], U], seq: Iterable[T]) → dict[U, list[T]][source]#

Group items by key. Unlike itertools.groupby, the input need not be sorted.

Parameters:

  • f (callable) – Key function.

  • seq (iterable) – Items.

Returns:

Maps each key to its items, in input order.

Return type:

dict[U, list[T]]

superleaf.sequences.serial.flatten(seq: Iterable, depth=None, drop_null=False) → list[source]#

Flatten nested sequences into a list. Strings are not split.

Parameters:

  • seq (iterable) – Possibly nested items.

  • depth (int, optional) – Levels to flatten. None (default) flattens completely.

  • drop_null (bool, optional) – If True, drop None and NaN items.

Returns:

Flattened items.

Return type:

list

superleaf.sequences.serial.flatmap(f: Callable, seq: Iterable, depth=None, drop_null=True) → list[source]#

Map f over seq and flatten the results.

Parameters:

  • f (callable) – Function applied to each item.

  • seq (iterable) – Items.

  • depth (int, optional) – Levels to flatten (see flatten()).

  • drop_null (bool, optional) – If True (default), drop None and NaN items.

Returns:

Flattened results.

Return type:

list

superleaf.sequences.serial.partitioned(f: Callable[[T], bool], seq: Iterable[T]) → tuple[list[T], list[T]][source]#

Split items by a predicate.

Parameters:

  • f (callable) – Predicate.

  • seq (iterable) – Items.

Returns:

  • list[T] – Items for which f is truthy, in input order.

  • list[T] – The remaining items, in input order.