A newtype wrapper around a Seq, representing a general-purpose finite sequence that is strict in its values.

This strictness is not enforced at the type level, but rather by the construction functions in this module. These functions essentially just wrap the original Data.Sequence functions while forcing the provided value to WHNF.

Convert a Seq into a StrictSeq by forcing each element to WHNF.

\( O(1) \). The empty sequence.

\( O(1) \). A singleton sequence.

\( O(1) \). Add an element to the left end of a sequence. Mnemonic: a triangle with the single element at the pointy end.

\( O(1) \). Add an element to the right end of a sequence. Mnemonic: a triangle with the single element at the pointy end.

\( O(\log(\min(n_1,n_2))) \). Concatenate two sequences.

\( O(1) \). Is this the empty sequence?

\( O(1) \). The number of elements in the sequence.

scanl is similar to foldl, but returns a sequence of reduced values from the left:

scanl f z (fromList [x1, x2, ...]) = fromList [z, z `f` x1, (z `f` x1) `f` x2, ...]

\( O(i) \) where \( i \) is the prefix length. takeWhileL, applied to a predicate p and a sequence xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.

\( O(i) \) where \( i \) is the suffix length. takeWhileR, applied to a predicate p and a sequence xs, returns the longest suffix (possibly empty) of xs of elements that satisfy p.

takeWhileR p xs is equivalent to reverse (takeWhileL p (reverse xs)).

\( O(i) \) where \( i \) is the prefix length. dropWhileL p xs returns the suffix remaining after takeWhileL p xs.

\( O(i) \) where \( i \) is the suffix length. dropWhileR p xs returns the prefix remaining after takeWhileR p xs.

dropWhileR p xs is equivalent to reverse (dropWhileL p (reverse xs)).

\( O(i) \) where \( i \) is the prefix length. spanl, applied to a predicate p and a sequence xs, returns a pair whose first element is the longest prefix (possibly empty) of xs of elements that satisfy p and the second element is the remainder of the sequence.

\( O(i) \) where \( i \) is the suffix length. spanr, applied to a predicate p and a sequence xs, returns a pair whose first element is the longest suffix (possibly empty) of xs of elements that satisfy p and the second element is the remainder of the sequence.

\( O(\log(\min(i,n-i))) \). The element at the specified position, counting from 0. If the specified position is negative or at least the length of the sequence, lookup returns Nothing.

0 <= i < length xs ==> lookup i xs == Just (toList xs !! i)

i < 0 || i >= length xs ==> lookup i xs = Nothing

Unlike index, this can be used to retrieve an element without forcing it. For example, to insert the fifth element of a sequence xs into a Map m at key k, you could use

case lookup 5 xs of
  Nothing -> m
  Just x -> insert k x m

\( O(\log(\min(i,n-i))) \). A flipped, infix version of lookup.

\( O(\log(\min(i,n-i))) \). The first i elements of a sequence. If i is negative, take i s yields the empty sequence. If the sequence contains fewer than i elements, the whole sequence is returned.

Take the last n elements

Returns the entire sequence if it has fewer than n elements.

Inherits asymptotic complexity from drop.

\( O(\log(\min(i,n-i))) \). Elements of a sequence after the first i. If i is negative, drop i s yields the whole sequence. If the sequence contains fewer than i elements, the empty sequence is returned.

Drop the last n elements

Returns the Empty sequence if it has fewer than n elements.

Inherits asymptotic complexity from take.

\( O(\log(\min(i,n-i))) \). Split a sequence at a given position. splitAt i s = (take i s, drop i s).

Split at the given position counting from the end of the sequence.

Inherits asymptotic complexity from splitAt.

findIndexL p xs finds the index of the leftmost element that satisfies p, if any exist.

findIndicesL p finds all indices of elements that satisfy p, in ascending order.

findIndexR p xs finds the index of the rightmost element that satisfies p, if any exist.

findIndicesR p finds all indices of elements that satisfy p, in descending order.