hydra.dsl.lib.lists module

DSL functions for hydra.overlay.python.lib.lists.

hydra.dsl.lib.lists.apply(fs: TypedTerm[Sequence[Callable[[X], Y]]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[Y]]

DSL reference to hydra.overlay.python.lib.lists.apply.

hydra.dsl.lib.lists.at(i: TypedTerm[int], xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.at.

hydra.dsl.lib.lists.bind(xs: TypedTerm[Sequence[X]], f: TypedTerm[Callable[[X], Sequence[Y]]]) → TypedTerm[Sequence[Y]]

DSL reference to hydra.overlay.python.lib.lists.bind.

hydra.dsl.lib.lists.compose(f: TypedTerm[Callable[[X], Sequence[Y]]], g: TypedTerm[Callable[[Y], Sequence[Z]]], x: TypedTerm[X]) → TypedTerm[Sequence[Z]]

DSL reference to hydra.overlay.python.lib.lists.compose.

hydra.dsl.lib.lists.concat(xss: TypedTerm[Sequence[Sequence[X]]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.concat.

hydra.dsl.lib.lists.concat2(xs: TypedTerm[Sequence[X]], ys: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.concat2.

hydra.dsl.lib.lists.cons(x: TypedTerm[X], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.cons.

hydra.dsl.lib.lists.distinct(xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.distinct.

hydra.dsl.lib.lists.drop(n: TypedTerm[int], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.drop.

hydra.dsl.lib.lists.drop_while(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.dropWhile.

hydra.dsl.lib.lists.filter(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.filter.

hydra.dsl.lib.lists.find(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.find.

hydra.dsl.lib.lists.fold_list(f: TypedTerm[Callable[[X, Y], Sequence[X]]], acc0: TypedTerm[X], xs: TypedTerm[Sequence[Y]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.foldList.

hydra.dsl.lib.lists.foldl(f: TypedTerm[Callable[[Y, X], Y]], acc0: TypedTerm[Y], xs: TypedTerm[Sequence[X]]) → TypedTerm[Y]

DSL reference to hydra.overlay.python.lib.lists.foldl.

hydra.dsl.lib.lists.foldr(f: TypedTerm[Callable[[X, Y], Y]], acc0: TypedTerm[Y], xs: TypedTerm[Sequence[X]]) → TypedTerm[Y]

DSL reference to hydra.overlay.python.lib.lists.foldr.

hydra.dsl.lib.lists.group(xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[Sequence[X]]]

DSL reference to hydra.overlay.python.lib.lists.group.

hydra.dsl.lib.lists.head(xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.head.

hydra.dsl.lib.lists.init(xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.init.

hydra.dsl.lib.lists.intersperse(sep: TypedTerm[X], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.intersperse.

hydra.dsl.lib.lists.is_empty(xs: TypedTerm[Sequence[X]]) → TypedTerm[bool]

DSL reference to hydra.overlay.python.lib.lists.isEmpty.

hydra.dsl.lib.lists.join(sep: TypedTerm[Sequence[X]], xss: TypedTerm[Sequence[Sequence[X]]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.join.

hydra.dsl.lib.lists.last(xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.last.

hydra.dsl.lib.lists.length(xs: TypedTerm[Sequence[X]]) → TypedTerm[int]

DSL reference to hydra.overlay.python.lib.lists.length.

hydra.dsl.lib.lists.map(f: TypedTerm[Callable[[X], Y]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[Y]]

DSL reference to hydra.overlay.python.lib.lists.map.

hydra.dsl.lib.lists.map_list(f: TypedTerm[Callable[[X], Sequence[Y]]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[Sequence[Y]]]

DSL reference to hydra.overlay.python.lib.lists.mapList.

hydra.dsl.lib.lists.map_optional(f: TypedTerm[Callable[[X], Sequence[Y]]], m: TypedTerm[object]) → TypedTerm[Sequence[object]]

DSL reference to hydra.overlay.python.lib.lists.mapOptional.

hydra.dsl.lib.lists.map_set(f: TypedTerm[Callable[[X], Sequence[Y]]], s: TypedTerm[Set[X]]) → TypedTerm[Sequence[Set[Y]]]

DSL reference to hydra.overlay.python.lib.lists.mapSet.

hydra.dsl.lib.lists.member(x: TypedTerm[X], xs: TypedTerm[Sequence[X]]) → TypedTerm[bool]

DSL reference to hydra.overlay.python.lib.lists.member.

hydra.dsl.lib.lists.partition(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[tuple[Sequence[X], Sequence[X]]]

DSL reference to hydra.overlay.python.lib.lists.partition.

hydra.dsl.lib.lists.replicate(n: TypedTerm[int], x: TypedTerm[X]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.replicate.

hydra.dsl.lib.lists.reverse(xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.reverse.

hydra.dsl.lib.lists.singleton(x: TypedTerm[X]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.singleton.

hydra.dsl.lib.lists.sort(xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.sort.

hydra.dsl.lib.lists.sort_by(f: TypedTerm[Callable[[X], Y]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.sortBy.

hydra.dsl.lib.lists.span(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[tuple[Sequence[X], Sequence[X]]]

DSL reference to hydra.overlay.python.lib.lists.span.

hydra.dsl.lib.lists.tail(xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.tail.

hydra.dsl.lib.lists.take(n: TypedTerm[int], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.take.

hydra.dsl.lib.lists.take_while(p: TypedTerm[Callable[[X], bool]], xs: TypedTerm[Sequence[X]]) → TypedTerm[Sequence[X]]

DSL reference to hydra.overlay.python.lib.lists.takeWhile.

hydra.dsl.lib.lists.transpose(xss: TypedTerm[Sequence[Sequence[X]]]) → TypedTerm[Sequence[Sequence[X]]]

DSL reference to hydra.overlay.python.lib.lists.transpose.

hydra.dsl.lib.lists.uncons(xs: TypedTerm[Sequence[X]]) → TypedTerm[object]

DSL reference to hydra.overlay.python.lib.lists.uncons.

hydra.dsl.lib.lists.zip(xs: TypedTerm[Sequence[X]], ys: TypedTerm[Sequence[Y]]) → TypedTerm[Sequence[tuple[X, Y]]]

DSL reference to hydra.overlay.python.lib.lists.zip.

hydra.dsl.lib.lists.zip_with(f: TypedTerm[Callable[[X, Y], Z]], xs: TypedTerm[Sequence[X]], ys: TypedTerm[Sequence[Y]]) → TypedTerm[Sequence[Z]]

DSL reference to hydra.overlay.python.lib.lists.zipWith.