indices finds the starting indices of all possibly overlapping occurrences of the pattern in the target string. If the pattern is empty, the result is [0 .. length target].

nonOverlappingIndices finds the starting indices of all non-overlapping occurrences of the pattern in the target string. It is more efficient than removing indices from the list produced by indices.

breakOn pattern target splits target at the first occurrence of pattern. If the pattern does not occur in the target, the second component of the result is empty, otherwise it starts with pattern. If the pattern is empty, the first component is empty. For a non-empty pattern, the first component is generated lazily, thus the first parts of it can be available before the pattern has been found or determined to be absent.

  uncurry append . breakOn pattern = id

breakAfter pattern target splits target behind the first occurrence of pattern. An empty second component means that either the pattern does not occur in the target or the first occurrence of pattern is at the very end of target. If you need to discriminate between those cases, use breakFindAfter. If the pattern is empty, the first component is empty. For a non-empty pattern, the first component is generated lazily, thus the first parts of it can be available before the pattern has been found or determined to be absent. uncurry append . breakAfter pattern = id

breakFindAfter does the same as breakAfter but additionally indicates whether the pattern is present in the target.

  fst . breakFindAfter pat = breakAfter pat

replace pat sub text replaces all (non-overlapping) occurrences of pat in text with sub. If occurrences of pat overlap, the first occurrence that does not overlap with a replaced previous occurrence is substituted. Occurrences of pat arising from a substitution will not be substituted. For example:

  replace "ana" "olog" "banana" = "bologna"
  replace "ana" "o" "bananana" = "bono"
  replace "aab" "abaa" "aaabb" = "aabaab"

The result is a lazy ByteString, which is lazily produced, without copying. Equality of pattern and substitution is not checked, but

  replace pat pat text == text

holds (the internal structure is generally different). If the pattern is empty but not the substitution, the result is equivalent to (were they Strings) cycle sub.

For non-empty pat and sub a lazy ByteString,

  concat . intersperse sub . split pat = replace pat sub

and analogous relations hold for other types of sub.

split pattern target splits target at each (non-overlapping) occurrence of pattern, removing pattern. If pattern is empty, the result is an infinite list of empty ByteStrings, if target is empty but not pattern, the result is an empty list, otherwise the following relations hold (where patL is the lazy ByteString corresponding to pat):

  concat . intersperse patL . split pat = id,
  length (split pattern target) ==
              length (nonOverlappingIndices pattern target) + 1,

no fragment in the result contains an occurrence of pattern.

splitKeepEnd pattern target splits target after each (non-overlapping) occurrence of pattern. If pattern is empty, the result is an infinite list of empty ByteStrings, otherwise the following relations hold:

  concat . splitKeepEnd pattern = 'id,'

all fragments in the result except possibly the last end with pattern, no fragment contains more than one occurrence of pattern.

splitKeepFront is like splitKeepEnd, except that target is split before each occurrence of pattern and hence all fragments with the possible exception of the first begin with pattern. No fragment contains more than one non-overlapping occurrence of pattern.