sequtils

nimony/lib/std/sequtils.nim

Operations on sequences (and openArrays), in the spirit of functional programming: map, filter, zip, folds and friends.

This is the Nimony port. It currently covers the callback- and value-oriented core.

func repeat(x: T; n: int64): seq[T]
Returns a sequence with x repeated n times.
func concat(a: openArray[T]; b: openArray[T]): seq[T]
Concatenates a and b into a fresh sequence.
func count(s: openArray[T]; x: T): int64
Returns the number of occurrences of x in s.
func deduplicate(s: openArray[T]): seq[T]
Returns s with consecutive and non-consecutive duplicates removed, preserving first-seen order.
func minIndex(s: openArray[T]): int64
Returns the index of the minimum element of s (0 for an empty s).
func maxIndex(s: openArray[T]): int64
Returns the index of the maximum element of s (0 for an empty s).
proc map(s: openArray[T]; op: proc (x: T): S): seq[S]
Returns a new sequence with op applied to every element of s.
proc filter(s: openArray[T]; pred: proc (x: T): bool): seq[T]
Returns the elements of s for which pred returns true.
proc keepIf(s: var seq[T]; pred: proc (x: T): bool)
In-place variant of filter: keeps only the elements for which pred returns true.
proc all(s: openArray[T]; pred: proc (x: T): bool): bool
Whether pred is true for every element (true for an empty s).
proc any(s: openArray[T]; pred: proc (x: T): bool): bool
Whether pred is true for at least one element (false for an empty s).
proc apply(s: var seq[T]; op: proc (x: T): T)
Applies op to every element of s in place.
func cycle(s: openArray[T]; n: int64): seq[T]
Returns a sequence with the elements of s repeated n times.
func zip(a: openArray[S]; b: openArray[T]): seq[tuple[S, T]]
Pairs up the elements of a and b, truncating to the shorter length.
func unzip(s: openArray[tuple[S, T]]): tuple[seq[S], seq[T]]
Splits a sequence of pairs into a pair of sequences.
func minmax(x: openArray[T]): tuple[T, T]
Returns the (minimum, maximum) of x in a single pass. Requires a non-empty x.
func delete(s: var seq[T]; first: int64; last: int64)
Deletes the elements s[first..last] (inclusive) in place, without building a fresh sequence: the survivors after last are swapped down over the gap, which leaves the dropped elements in the tail, and shrink then destroys exactly those dropped elements.
func insert(dest: var seq[T]; src: openArray[T]; pos: int64)
Inserts the elements of src into dest at position pos, in place: the storage is grown once and the tail shifted up, rather than materialising a whole new sequence.
template toSeq(iter: untyped): untyped
Materializes any iterable (a collection, a range, an iterator call, …) into a seq. Example: toSeq(1 .. 3) == @[1, 2, 3]; toSeq("ab") == @['a', 'b'].
template foldl(s: untyped; operation: untyped): untyped
Left-associative fold. a is the accumulator (seeded with the first element), b the current element.
template foldr(s: untyped; operation: untyped): untyped
Right-associative fold. a is the current element, b the accumulator (seeded with the last element).
template anyIt(s: untyped; pred: untyped): bool
Whether pred (referencing the injected it) holds for any element.
template allIt(s: untyped; pred: untyped): bool
Whether pred (referencing the injected it) holds for every element.
template countIt(s: untyped; pred: untyped): int64
Number of elements for which pred (referencing the injected it) holds.
template mapIt(s: untyped; op: untyped): untyped
Returns a new sequence with op (referencing the injected it) applied to every element. The result element type is typeof(op). Example: mapIt(@[1, 2, 3], it * 10) == @[10, 20, 30].
template filterIt(s: untyped; pred: untyped): untyped
Returns the elements for which pred (referencing the injected it) holds. Example: filterIt(@[1, 2, 3, 4], it mod 2 == 0) == @[2, 4].
template keepItIf(s: untyped; pred: untyped)
In-place filterIt: keeps only the elements of the seq s for which pred (referencing the injected it) holds. Example: keepItIf(data, it mod 2 == 1).
template applyIt(varSeq: untyped; op: untyped)
In-place mapIt: replaces each element of the seq varSeq with op (referencing the injected it). op must yield the element type. Example: applyIt(nums, it * 3).
template newSeqWith(len: int64; init: untyped): untyped
Creates a seq of length len, evaluating init for each element — handy for 2D seqs (newSeqWith(5, newSeq[int](3))) or per-element initialization.