q5             ! " # $ % & ' ( ) * +,- . / 0 1 2 3 4 non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>: finds all occurrences of any of several non-empty strict I patterns in a lazy target string. If no non-empty patterns are given, C the result is an empty list. Otherwise the result list contains H the pairs of all indices where any of the (non-empty) patterns start K and the list of all patterns starting at that index, the patterns being C represented by their (zero-based) position in the pattern list. = Empty patterns are filtered out before processing begins. List of non-empty patterns String to search List of matches 56789:non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>< finds all occurrences of any of several non-empty patterns B in a strict target string. If no non-empty patterns are given, C the result is an empty list. Otherwise the result list contains H the pairs of all indices where any of the (non-empty) patterns start K and the list of all patterns starting at that index, the patterns being C represented by their (zero-based) position in the pattern list. = Empty patterns are filtered out before processing begins. List of non-empty patterns String to search List of matches ;<=>?  Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com> @ABCDEFGHIJ @ABCEFGHIJ @ABCEFGHIJ non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>KK- finds all indices of (possibly overlapping) 4 occurrences of the pattern in the target string. Strict pattern Lazy target string Offsets of matches LL- finds all indices of (possibly overlapping) 4 occurrences of the pattern in the target string. Strict pattern Strict target string Offsets of matches # finds the starting indices of all non-overlapping occurrences F of the pattern in the target string. It is a simple wrapper around  5Data.ByteString.Lazy.Search.KMP.nonOverlappingIndices strictifying  the pattern.  Lazy pattern Lazy target string Offsets of matches # finds the starting indices of all non-overlapping occurrences F of the pattern in the target string. It is a simple wrapper around  0Data.ByteString.Search.KMP.nonOverlappingIndices strictifying  the pattern.  Lazy pattern Strict target string Offsets of matches # finds the starting indices of all non-overlapping occurrences ; of the pattern in the target string. It is an alias for  0Data.ByteString.Search.KMP.nonOverlappingIndices. Strict pattern Strict target string Offsets of matches # finds the starting indices of all non-overlapping occurrences ; of the pattern in the target string. It is an alias for  5Data.ByteString.Lazy.Search.KMP.nonOverlappingIndices. Strict pattern Lazy target string Offsets of matches MKLKLnon-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target]. Pattern to find String to search Offsets of matches # finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by . Pattern to find String to search Offsets of matches non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target]. Strict pattern to find Lazy string to search Offsets of matches  # finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by . Strict pattern to find Lazy string to search Offsets of matches   transforms a lazy O into a strict  P2, to make it a suitable pattern for the searching  functions.    portable Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com> =Type class of meaningful substitutions for replace functions A on ByteStrings. Instances for strict and lazy ByteStrings are  provided here.  0 transforms a value to a substitution function.   sub lazyBS& shall prepend infinitely many copies  of sub to lazyBS+ without entering an infinite loop in case  of an empty sub , so e.g.      "" "ab" == "ab" shall (quickly) evaluate to Q.  For non-empty sub., the cycle shall be constructed efficiently.     non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string.  It is a simple wrapper for #Data.ByteString.Lazy.Search.indices. * If the pattern is empty, the result is [0 .. N target].  Lazy pattern Lazy target string Offsets of matches 8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string.  It is an alias for #Data.ByteString.Lazy.Search.indices. * If the pattern is empty, the result is [0 .. N target]. Strict pattern Lazy target string Offsets of matches RR6 finds the indices of all non-overlapping occurrences - of the pattern in the lazy target string. Strict pattern Lazy target string Offsets of matches SPattern to replace Substitution string Target string  Lazy result T1The analogous function for a lazy target string. B The first component is generated lazily, so parts of it can be E available before the pattern is detected (or found to be absent). Pattern to break on String to break up &Prefix and remainder of broken string UVWPattern to split on String to split List of fragments XPattern to split on String to split List of fragments YPattern to split on String to split List of fragments Z[\]^_ RSTUVWXY RSTUVWXYnon-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com> 8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target]. Pattern to find String to search Offsets of matches # finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by . Pattern to find String to search Offsets of matches  pattern target splits target at the first occurrence  of pattern3. If the pattern does not occur in the target, the E second component of the result is empty, otherwise it starts with  pattern9. If the pattern is empty, the first component is empty.   ` a .  pattern = b String to search for String to search in ,Head and tail of string broken at substring  pattern target splits target behind the first occurrence  of pattern:. An empty second component means that either the pattern I does not occur in the target or the first occurrence of pattern is at I the very end of target. To discriminate between those cases, use e.g.  c.   ` a .  pattern = b String to search for String to search in /Head and tail of string broken after substring  pat sub text/ replaces all (non-overlapping) occurrences of  pat in text with sub. If occurrences of pat overlap, the first H 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:     "ana" "olog" "banana" = "bologna"   "ana" "o" "bananana" = "bono"   "aab" "abaa" "aaabb" = "aabaab" The result is a lazy O, . which is lazily produced, without copying. < Equality of pattern and substitution is not checked, but    d . e $  pat pat text == text Dholds. If the pattern is empty but not the substitution, the result  is equivalent to (were they fs) g sub. For non-empty pat and sub a strict P,    h . Data.List.intersperse sub .  pat =  pat sub 0and analogous relations hold for other types of sub. Substring to replace Replacement string String to modify  Lazy result  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 Ps, if target  is empty but not pattern), the result is an empty list, otherwise ! the following relations hold:    d . Data.List.intersperse pat .  pat = b,  N ( pattern target) ==  N ( pattern target) + 1, 4no fragment in the result contains an occurrence of pattern. Pattern to split on String to split Fragments of string  pattern target splits target after each (non-overlapping)  occurrence of pattern. If pattern is empty, the result is an  infinite list of empty Ps, otherwise the following  relations hold:    d .  pattern = b, >all fragments in the result except possibly the last end with  pattern3, no fragment contains more than one occurrence of pattern. Pattern to split on String to split Fragments of string  is like , except that target is split  before each occurrence of pattern and hence all fragments 7 with the possible exception of the first begin with pattern. A No fragment contains more than one non-overlapping occurrence  of pattern. Pattern to split on String to split Fragments of string i non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com> 8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target]. Strict pattern to find Lazy string to search Offsets of matches # finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by . Strict pattern to find Lazy string to search Offsets of matches  pattern target splits target at the first occurrence  of pattern3. If the pattern does not occur in the target, the E second component of the result is empty, otherwise it starts with  pattern9. If the pattern is empty, the first component is empty. E For a non-empty pattern, the first component is generated lazily, F thus the first parts of it can be available before the pattern has * been found or determined to be absent.   ` j .  pattern = b Strict pattern to search for Lazy string to search in ,Head and tail of string broken at substring  pattern target splits target behind the first occurrence  of pattern:. An empty second component means that either the pattern I does not occur in the target or the first occurrence of pattern is at L 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. E For a non-empty pattern, the first component is generated lazily, F thus the first parts of it can be available before the pattern has * been found or determined to be absent.   ` j .  pattern = b Strict pattern to search for Lazy string to search in /Head and tail of string broken after substring  does the same as  but additionally indicates 1 whether the pattern is present in the target.   k .  pat =  pat Strict pattern to search for Lazy string to search in /Head and tail of string broken after substring  and presence of pattern  pat sub text/ replaces all (non-overlapping) occurrences of  pat in text with sub. If occurrences of pat overlap, the first H 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:     "ana" "olog" "banana" = "bologna"   "ana" "o" "bananana" = "bono"   "aab" "abaa" "aaabb" = "aabaab" The result is a lazy O, . which is lazily produced, without copying. < Equality of pattern and substitution is not checked, but     pat pat text == text 7holds (the internal structure is generally different). @ If the pattern is empty but not the substitution, the result  is equivalent to (were they fs)  cycle sub. For non-empty pat and sub a lazy O,    l . Data.List.intersperse sub .  pat =  pat sub 0and analogous relations hold for other types of sub. Strict pattern to replace Replacement string Lazy string to modify  Lazy result  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 Os, if target  is empty but not pattern), the result is an empty list, otherwise ' the following relations hold (where patL is the lazy O  corresponding to pat):    l . Data.List.intersperse patL .  pat = b,  N ( pattern target) ==  N ( pattern target) + 1, 4no fragment in the result contains an occurrence of pattern. Strict pattern to split on Lazy string to split Fragments of string  pattern target splits target after each (non-overlapping)  occurrence of pattern. If pattern is empty, the result is an  infinite list of empty Os, otherwise the following  relations hold:    l .  pattern = b, >all fragments in the result except possibly the last end with  pattern3, no fragment contains more than one occurrence of pattern. Strict pattern to split on Lazy string to split Fragments of string   is like , except that target is split  before each occurrence of pattern and hence all fragments 7 with the possible exception of the first begin with pattern. A No fragment contains more than one non-overlapping occurrence  of pattern. Strict pattern to split on Lazy string to split Fragments of string !! converts a lazy O to a strict P " to make it a suitable pattern.  !  !  ! non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com> ""8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target]. Strict pattern to find Lazy string to search Offsets of matches ### finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by ". Strict pattern to find Lazy string to search Offsets of matches $$ pattern target splits target at the first occurrence  of pattern3. If the pattern does not occur in the target, the E second component of the result is empty, otherwise it starts with  pattern9. If the pattern is empty, the first component is empty. E For a non-empty pattern, the first component is generated lazily, F thus the first parts of it can be available before the pattern has * been found or determined to be absent.   ` j . $ pattern = b Strict pattern to search for Lazy string to search in ,Head and tail of string broken at substring %% pattern target splits target behind the first occurrence  of pattern:. An empty second component means that either the pattern I does not occur in the target or the first occurrence of pattern is at L 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. E For a non-empty pattern, the first component is generated lazily, F thus the first parts of it can be available before the pattern has * been found or determined to be absent.    ` j . % pattern = b   Strict pattern to search for Lazy string to search in /Head and tail of string broken after substring && does the same as % but additionally indicates 1 whether the pattern is present in the target.   k . & pat = % pat Strict pattern to search for Lazy string to search in /Head and tail of string broken after substring  and presence of pattern '' pat sub text/ replaces all (non-overlapping) occurrences of  pat in text with sub. If occurrences of pat overlap, the first H 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:    ' "ana" "olog" "banana" = "bologna"  ' "ana" "o" "bananana" = "bono"  ' "aab" "abaa" "aaabb" = "aabaab" The result is a lazy O, . which is lazily produced, without copying. < Equality of pattern and substitution is not checked, but    ' pat pat text == text 7holds (the internal structure is generally different). @ If the pattern is empty but not the substitution, the result  is equivalent to (were they fs)  cycle sub. For non-empty pat and sub a lazy O,    l . Data.List.intersperse sub . ( pat = ' pat sub 0and analogous relations hold for other types of sub. Strict pattern to replace Replacement string Lazy string to modify  Lazy result (( 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 Os, if target  is empty but not pattern), the result is an empty list, otherwise ' the following relations hold (where patL is the lazy O  corresponding to pat):    l . Data.List.intersperse patL . ( pat = b,  N (( pattern target) ==  N (# pattern target) + 1, 4no fragment in the result contains an occurrence of pattern. Strict pattern to split on Lazy string to split Fragments of string )) pattern target splits target after each (non-overlapping)  occurrence of pattern. If pattern is empty, the result is an  infinite list of empty Os, otherwise the following  relations hold:    l . ) pattern = 'id,' >all fragments in the result except possibly the last end with  pattern3, no fragment contains more than one occurrence of pattern. Strict pattern to split on Lazy string to split Fragments of string ** is like ), except that target is split  before each occurrence of pattern and hence all fragments 7 with the possible exception of the first begin with pattern. A No fragment contains more than one non-overlapping occurrence  of pattern. Strict pattern to split on Lazy string to split Fragments of string mno "#$%&'()* "#$%&'()* "#$%&'()*non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>++8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string.  It is a simple wrapper for Data.ByteString.Search.indices. * If the pattern is empty, the result is [0 .. N target].  Lazy pattern Strict target string Offsets of matches ,,8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string.  It is an alias for Data.ByteString.Search.indices. * If the pattern is empty, the result is [0 .. N target]. Strict pattern Strict target string Offsets of matches pp6 finds the indices of all non-overlapping occurrences / of the pattern in the Strict target string. Strict pattern Strict target string Offsets of matches qPattern to replace Substitution string Target string  Lazy result r(This function has the same semantics as s ! but is generally much faster. Pattern to break on String to break up &Prefix and remainder of broken string tuPattern to split on String to split List of fragments vPattern to split on String to split List of fragments wPattern to split on String to split List of fragments xyz{|} +,pqrtuvw +,pqrtuvwnon-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>+,+, non-portable (BangPatterns) Provisional1Daniel Fischer <daniel.is.fischer@googlemail.com>--8 finds the starting indices of all possibly overlapping 4 occurrences of the pattern in the target string. * If the pattern is empty, the result is [0 .. N target].  In general, ~ .  $ - pat target is a much more  efficient version of . Pattern to find String to search Offsets of matches ..# finds the starting indices of all D non-overlapping occurrences of the pattern in the target string. E It is more efficient than removing indices from the list produced  by -. Pattern to find String to search Offsets of matches // pattern target splits target at the first occurrence  of pattern3. If the pattern does not occur in the target, the E second component of the result is empty, otherwise it starts with  pattern9. If the pattern is empty, the first component is empty.   ` a . / pattern = b String to search for String to search in ,Head and tail of string broken at substring 00 pattern target splits target behind the first occurrence  of pattern:. An empty second component means that either the pattern I does not occur in the target or the first occurrence of pattern is at I the very end of target. To discriminate between those cases, use e.g.  c.   ` a . 0 pattern = b String to search for String to search in /Head and tail of string broken after substring 11 pat sub text/ replaces all (non-overlapping) occurrences of  pat in text with sub. If occurrences of pat overlap, the first H 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:    1 "ana" "olog" "banana" = "bologna"  1 "ana" "o" "bananana" = "bono"  1 "aab" "abaa" "aaabb" = "aabaab" The result is a lazy O, . which is lazily produced, without copying. < Equality of pattern and substitution is not checked, but    (d . e $ 1 pat pat text) == text Dholds. If the pattern is empty but not the substitution, the result  is equivalent to (were they fs) g sub. For non-empty pat and sub a strict P,    h . Data.List.intersperse sub . 2 pat = 1 pat sub 0and analogous relations hold for other types of sub. Substring to replace Replacement string String to modify  Lazy result 22 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 Ps, if target  is empty but not pattern), the result is an empty list, otherwise ! the following relations hold:    d . Data.List.intersperse pat . 2 pat = b,  N (2 pattern target) ==  N (. pattern target) + 1, 4no fragment in the result contains an occurrence of pattern. Pattern to split on String to split Fragments of string 33 pattern target splits target after each (non-overlapping)  occurrence of pattern. If pattern is empty, the result is an  infinite list of empty Ps, otherwise the following  relations hold:    d . 3 pattern = b, >all fragments in the result except possibly the last end with  pattern3, no fragment contains more than one occurrence of pattern. Pattern to split on String to split Fragments of string 44 is like 3, except that target is split  before each occurrence of pattern and hence all fragments 7 with the possible exception of the first begin with pattern. A No fragment contains more than one non-overlapping occurrence  of pattern. Pattern to split on String to split Fragments of string -./01234-./01234-./01234         !         !            "#$%&'"#$%( ) * + , -  . / 0 1 2 3 4 56789:;9<;=>?@ABCDEFGHIJKLM6NO9PQ6RS9PT9PU9VW6RX67Y9VZ[9VQ6N\9VU H ] ^_`a9Pbcdef[ghijk6lm67n9Popstringsearch-0.3.6.1%Data.ByteString.Lazy.Search.KarpRabin Data.ByteString.Search.KarpRabin'Data.ByteString.Search.KnuthMorrisPrattData.ByteString.Search.KMPData.ByteString.Lazy.Search.KMP#Data.ByteString.Search.Substitution!Data.ByteString.Search.BoyerMooreData.ByteString.Search.DFAData.ByteString.Lazy.SearchData.ByteString.Lazy.Search.DFAData.ByteString.Search%Data.ByteString.Search.Internal.Utils0Data.ByteString.Search.Internal.KnuthMorrisPratt/Data.ByteString.Lazy.Search.Internal.BoyerMoore*Data.ByteString.Search.Internal.BoyerMoore indicesOfAnymatchLLmatchLSmatchSSmatchSLindicesnonOverlappingIndices strictify Substitution substitution prependCyclebreakOn breakAfterreplacesplit splitKeepEndsplitKeepFrontbreakFindAfterrehash1rehash2rehash3rehash4 lazyMatchercheckFut strictMatcher automaton kmpBordersoccurs suffShifts suffLengthsldropltakelsplitreleasekeepindicesLindicesSmatcherbaseGHC.Listlengthbytestring-0.9.1.10Data.ByteString.Lazy.Internal ByteStringData.ByteString.Internalghc-primGHC.BoolTruematchNOL replaceAllLbreakSubstringL breakAfterLbreakFindAfterL splitKeepEndLsplitKeepFrontL splitDropL lazySearcher lazyBreaklazySplitKeepFrontlazySplitKeepEnd lazySplitDroplazyRepl Data.TupleuncurryData.ByteStringappendGHC.Baseid isSuffixOfconcatData.ByteString.LazytoChunksStringcycle fromChunksstrictSearcherfst lazyBreakerrgomatchNOS replaceAllSbreakSubstringSbreakSubstring breakAfterS splitKeepEndSsplitKeepFrontS splitDropS strictBreakstrictSplitKeepFrontstrictSplitKeepEndstrictSplitDrop strictRepl GHC.Classesnotnull isInfixOf