Commits

dafis committed 10c0c71

Cleaned up the docs and fixed a typo in an example.

  • Participants
  • Parent commits 48aebe8
  • Tags 0.3.6.1

Comments (0)

Files changed (15)

+0.3.6.1:
+- fix error in docs
 0.3.6:
 - fix typos in haddocks
 0.3.5:

File Data/ByteString/Lazy/Search.hs

 --                            Exported Functions                            --
 ------------------------------------------------------------------------------
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 {-# INLINE indices #-}
         -> [Int64]          -- ^ Offsets of matches
 indices = BM.matchSL
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.
                       -> [Int64]        -- ^ Offsets of matches
 nonOverlappingIndices = BM.matchNOL
 
--- | @breakOn pattern target@ splits @target@ at the first occurrence
+-- | @'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.
                          -- ^ Head and tail of string broken at substring
 breakOn = BM.breakSubstringL
 
--- | @breakAfter pattern target@ splits @target@ behind the first occurrence
+-- | @'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,
                             -- ^ Head and tail of string broken after substring
 breakAfter = BM.breakAfterL
 
--- | @breakFindAfter@ does the same as 'breakAfter' but additionally indicates
+-- | @'breakFindAfter'@ does the same as 'breakAfter' but additionally indicates
 --   whether the pattern is present in the target.
 --
 -- @
                             --   and presence of pattern
 breakFindAfter = BM.breakFindAfterL
 
--- | @replace pat sub text@ replaces all (non-overlapping) occurrences of
+-- | @'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
 -- @
 --   'replace' \"ana\" \"olog\" \"banana\" = \"bologna\"
 --   'replace' \"ana\" \"o\" \"bananana\" = \"bono\"
---   'replace' \"aab\" \"abaa\" \"aaab\" = \"abaaab\"
+--   'replace' \"aab\" \"abaa\" \"aaabb\" = \"aabaab\"
 -- @
 --
---   The result is a /lazy/ 'L.ByteString',
+--   The result is a lazy 'L.ByteString',
 --   which is lazily produced, without copying.
 --   Equality of pattern and substitution is not checked, but
 --
         -> L.ByteString     -- ^ Lazy result
 replace = BM.replaceAllL
 
--- | @split pattern target@ splits @target@ at each (non-overlapping)
+-- | @'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 'L.ByteString's, if @target@
 --   is empty but not @pattern@, the result is an empty list, otherwise
       -> [L.ByteString] -- ^ Fragments of string
 split = BM.splitDropL
 
--- | @splitKeepEnd pattern target@ splits @target@ after each (non-overlapping)
+-- | @'splitKeepEnd' pattern target@ splits @target@ after each (non-overlapping)
 --   occurrence of @pattern@. If @pattern@ is empty, the result is an
 --   infinite list of empty 'L.ByteString's, otherwise the following
 --   relations hold:
              -> [L.ByteString]  -- ^ Fragments of string
 splitKeepEnd = BM.splitKeepEndL
 
--- | @splitKeepFront@ is like 'splitKeepEnd', except that @target@ is split
+-- | @'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
                -> [L.ByteString]  -- ^ Fragments of string
 splitKeepFront = BM.splitKeepFrontL
 
--- | @strictify@ converts a lazy 'L.ByteString' to a strict 'S.ByteString'
+-- | @'strictify'@ converts a lazy 'L.ByteString' to a strict 'S.ByteString'
 --   to make it a suitable pattern.
 strictify :: L.ByteString -> S.ByteString
 strictify = S.concat . L.toChunks

File Data/ByteString/Lazy/Search/DFA.hs

 --                            Exported Functions                            --
 ------------------------------------------------------------------------------
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 {-# INLINE indices #-}
         -> [Int64]          -- ^ Offsets of matches
 indices !pat = lazySearcher True pat . L.toChunks
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.
                       -> [Int64]        -- ^ Offsets of matches
 nonOverlappingIndices !pat = lazySearcher False pat . L.toChunks
 
--- | @breakOn pattern target@ splits @target@ at the first occurrence
+-- | @'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.
     breaker strs = let (f, b) = lbrk strs
                    in (L.fromChunks f, L.fromChunks b)
 
--- | @breakAfter pattern target@ splits @target@ behind the first occurrence
+-- | @'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,
     breaker strs = let (f, b) = lbrk strs
                    in (L.fromChunks f, L.fromChunks b)
 
--- | @breakFindAfter@ does the same as 'breakAfter' but additionally indicates
+-- | @'breakFindAfter'@ does the same as 'breakAfter' but additionally indicates
 --   whether the pattern is present in the target.
 --
 -- @
                        mbpat = L.fromChunks f1
                    in ((foldr LI.chunk mbpat f, L.fromChunks b1), not (null b))
 
--- | @replace pat sub text@ replaces all (non-overlapping) occurrences of
+-- | @'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
 -- @
 --   'replace' \"ana\" \"olog\" \"banana\" = \"bologna\"
 --   'replace' \"ana\" \"o\" \"bananana\" = \"bono\"
---   'replace' \"aab\" \"abaa\" \"aaab\" = \"abaaab\"
+--   'replace' \"aab\" \"abaa\" \"aaabb\" = \"aabaab\"
 -- @
 --
---   The result is a /lazy/ 'L.ByteString',
+--   The result is a lazy 'L.ByteString',
 --   which is lazily produced, without copying.
 --   Equality of pattern and substitution is not checked, but
 --
                in L.fromChunks . repl1 . L.toChunks
 
 
--- | @split pattern target@ splits @target@ at each (non-overlapping)
+-- | @'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 'L.ByteString's, if @target@
 --   is empty but not @pattern@, the result is an empty list, otherwise
                     [] -> []
                     _  -> splitter' (ldrop patLen mtch)
 
--- | @splitKeepEnd pattern target@ splits @target@ after each (non-overlapping)
+-- | @'splitKeepEnd' pattern target@ splits @target@ after each (non-overlapping)
 --   occurrence of @pattern@. If @pattern@ is empty, the result is an
 --   infinite list of empty 'L.ByteString's, otherwise the following
 --   relations hold:
       case breaker strs of
         (pre, mtch) -> pre : splitter mtch
 
--- | @splitKeepFront@ is like 'splitKeepEnd', except that @target@ is split
+-- | @'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

File Data/ByteString/Lazy/Search/Internal/BoyerMoore.hs

 --
 -- is a much more efficient version of 'S.isInfixOf'.
 
--- | @matchLL@ finds the starting indices of all possibly overlapping
+-- | @'matchLL'@ finds the starting indices of all possibly overlapping
 --   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 .. 'length' target]@.
   where
     search  = lazySearcher True (strictify pat)
 
--- | @matchSL@ finds the starting indices of all possibly overlapping
+-- | @'matchSL'@ finds the starting indices of all possibly overlapping
 --   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 .. 'length' target]@.
   where
     search = lazySearcher True pat
 
--- | matchNOL finds the indices of all non-overlapping occurrences
+-- | @'matchNOL'@ finds the indices of all non-overlapping occurrences
 --   of the pattern in the lazy target string.
 {-# INLINE matchNOL #-}
 matchNOL :: S.ByteString    -- ^ Strict pattern

File Data/ByteString/Lazy/Search/KMP.hs

 -- pattern, the auxiliary data will be computed only once, allowing for
 -- efficient re-use.
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 {-# INLINE indices #-}
         -> [Int64]          -- ^ Offsets of matches
 indices = indicesL
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.
                       -> [Int64]        -- ^ Offsets of matches
 nonOverlappingIndices = matchSL
 
--- | @strictify@ transforms a lazy 'L.ByteString' into a strict
+-- | @'strictify'@ transforms a lazy 'L.ByteString' into a strict
 --   'S.ByteString', to make it a suitable pattern for the searching
 --   functions.
 strictify :: L.ByteString -> S.ByteString

File Data/ByteString/Lazy/Search/KarpRabin.hs

 -- Nevertheless, this module seems more of an interesting curiosity than
 -- anything else.
 
--- | @indicesOfAny@ finds all occurrences of any of several non-empty strict
+-- | @'indicesOfAny'@ finds all occurrences of any of several non-empty strict
 --   patterns in a lazy target string. If no non-empty patterns are given,
 --   the result is an empty list. Otherwise the result list contains
 --   the pairs of all indices where any of the (non-empty) patterns start

File Data/ByteString/Search.hs

 --                            Exported Functions                            --
 ------------------------------------------------------------------------------
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 --
         -> [Int]            -- ^ Offsets of matches
 indices = BM.matchSS
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.
                       -> [Int]          -- ^ Offsets of matches
 nonOverlappingIndices = BM.matchNOS
 
--- | @breakOn pattern target@ splits @target@ at the first occurrence
+-- | @'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.
                          -- ^ Head and tail of string broken at substring
 breakOn = BM.breakSubstringS
 
--- | @breakAfter pattern target@ splits @target@ behind the first occurrence
+-- | @'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. To discriminate between those cases, use e.g.
                             -- ^ Head and tail of string broken after substring
 breakAfter = BM.breakAfterS
 
--- | @replace pat sub text@ replaces all (non-overlapping) occurrences of
+-- | @'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
 -- @
 --   'replace' \"ana\" \"olog\" \"banana\" = \"bologna\"
 --   'replace' \"ana\" \"o\" \"bananana\" = \"bono\"
---   'replace' \"aab\" \"abaa\" \"aaab\" = \"abaaab\"
+--   'replace' \"aab\" \"abaa\" \"aaabb\" = \"aabaab\"
 -- @
 --
 --   The result is a /lazy/ 'L.ByteString',
 -- @
 --
 --   holds. If the pattern is empty but not the substitution, the result
---   is equivalent to (were they 'String's) @cycle sub@.
+--   is equivalent to (were they 'String's) @'cycle' sub@.
 --
 --   For non-empty @pat@ and @sub@ a strict 'S.ByteString',
 --
         -> L.ByteString     -- ^ Lazy result
 replace = BM.replaceAllS
 
--- | @split pattern target@ splits @target@ at each (non-overlapping)
+-- | @'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 'S.ByteString's, if @target@
 --   is empty but not @pattern@, the result is an empty list, otherwise
       -> [S.ByteString] -- ^ Fragments of string
 split = BM.splitDropS
 
--- | @splitKeepEnd pattern target@ splits @target@ after each (non-overlapping)
+-- | @'splitKeepEnd' pattern target@ splits @target@ after each (non-overlapping)
 --   occurrence of @pattern@. If @pattern@ is empty, the result is an
 --   infinite list of empty 'S.ByteString's, otherwise the following
 --   relations hold:
              -> [S.ByteString]  -- ^ Fragments of string
 splitKeepEnd = BM.splitKeepEndS
 
--- | @splitKeepFront@ is like 'splitKeepEnd', except that @target@ is split
+-- | @'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

File Data/ByteString/Search/BoyerMoore.hs

 -- Portability    : non-portable (BangPatterns)
 --
 -- Fast overlapping Boyer-Moore search of both strict and lazy
--- 'S.ByteString' values.
+-- 'ByteString' values.
 --
 -- Descriptions of the algorithm can be found at
 -- <http://www-igm.univ-mlv.fr/~lecroq/string/node14.html#SECTION00140>

File Data/ByteString/Search/DFA.hs

 --                            Exported Functions                            --
 ------------------------------------------------------------------------------
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 {-# INLINE indices #-}
         -> [Int]            -- ^ Offsets of matches
 indices = strictSearcher True
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.
                       -> [Int]          -- ^ Offsets of matches
 nonOverlappingIndices = strictSearcher False
 
--- | @breakOn pattern target@ splits @target@ at the first occurrence
+-- | @'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.
                     []      -> (str, S.empty)
                     (i:_)   -> S.splitAt i str
 
--- | @breakAfter pattern target@ splits @target@ behind the first occurrence
+-- | @'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. To discriminate between those cases, use e.g.
                     (i:_)   -> S.splitAt (i + patLen) str
 
 
--- | @replace pat sub text@ replaces all (non-overlapping) occurrences of
+-- | @'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
 -- @
 --   'replace' \"ana\" \"olog\" \"banana\" = \"bologna\"
 --   'replace' \"ana\" \"o\" \"bananana\" = \"bono\"
---   'replace' \"aab\" \"abaa\" \"aaab\" = \"abaaab\"
+--   'replace' \"aab\" \"abaa\" \"aaabb\" = \"aabaab\"
 -- @
 --
 --   The result is a /lazy/ 'L.ByteString',
           in replacer
     in \sub -> L.fromChunks . repl sub
 
--- | @split pattern target@ splits @target@ at each (non-overlapping)
+-- | @'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 'S.ByteString's, if @target@
 --   is empty but not @pattern@, the result is an empty list, otherwise
           []    -> [str]
           (i:_) -> S.take i str : splitter' (S.drop (i + patLen) str)
 
--- | @splitKeepEnd pattern target@ splits @target@ after each (non-overlapping)
+-- | @'splitKeepEnd' pattern target@ splits @target@ after each (non-overlapping)
 --   occurrence of @pattern@. If @pattern@ is empty, the result is an
 --   infinite list of empty 'S.ByteString's, otherwise the following
 --   relations hold:
           (i:_) -> S.take (i + patLen) str :
                         splitter (S.drop (i + patLen) str)
 
--- | @splitKeepFront@ is like 'splitKeepEnd', except that @target@ is split
+-- | @'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

File Data/ByteString/Search/Internal/BoyerMoore.hs

 --
 -- is a much more efficient version of 'S.isInfixOf'.
 
--- | @matchLS@ finds the starting indices of all possibly overlapping
+-- | @'matchLS'@ finds the starting indices of all possibly overlapping
 --   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 .. 'length' target]@.
   where
     search = strictSearcher True (strictify pat)
 
--- | @matchSS@ finds the starting indices of all possibly overlapping
+-- | @'matchSS'@ finds the starting indices of all possibly overlapping
 --   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 .. 'length' target]@.
   where
     search = strictSearcher True pat
 
--- | matchNOS finds the indices of all non-overlapping occurrences
+-- | @'matchNOS'@ finds the indices of all non-overlapping occurrences
 --   of the pattern in the Strict target string.
 {-# INLINE matchNOS #-}
 matchNOS :: S.ByteString    -- ^ Strict pattern

File Data/ByteString/Search/Internal/KnuthMorrisPratt.hs

 --                                 Wrappers                                 --
 ------------------------------------------------------------------------------
 
--- | @indicesL@ finds all indices of (possibly overlapping)
+-- | @'indicesL'@ finds all indices of (possibly overlapping)
 --   occurrences of the pattern in the target string.
 {-# INLINE indicesL #-}
 indicesL :: S.ByteString     -- ^ Strict pattern
   where
     search = matcher True pat
 
--- | @indicesS@ finds all indices of (possibly overlapping)
+-- | @'indicesS'@ finds all indices of (possibly overlapping)
 --   occurrences of the pattern in the target string.
 {-# INLINE indicesS #-}
 indicesS :: S.ByteString     -- ^ Strict pattern
   where
     search = matcher True pat
 
--- | @matchLL@ finds the starting indices of all /non-overlapping/ occurrences
+-- | @'matchLL'@ finds the starting indices of all /non-overlapping/ occurrences
 --   of the pattern in the target string. It is a simple wrapper around
 --   'Data.ByteString.Lazy.Search.KMP.nonOverlappingIndices' strictifying
 --   the pattern.
     !spat = strictify pat
     search = matcher False spat
 
--- | @matchLS@ finds the starting indices of all /non-overlapping/ occurrences
+-- | @'matchLS'@ finds the starting indices of all /non-overlapping/ occurrences
 --   of the pattern in the target string. It is a simple wrapper around
 --   'Data.ByteString.Search.KMP.nonOverlappingIndices' strictifying
 --   the pattern.
     !spat = strictify pat
     search = matcher False spat
 
--- | @matchSS@ finds the starting indices of all /non-overlapping/ occurrences
+-- | @'matchSS'@ finds the starting indices of all /non-overlapping/ occurrences
 --   of the pattern in the target string. It is an alias for
 --   'Data.ByteString.Search.KMP.nonOverlappingIndices'.
 {-# INLINE matchSS #-}
   where
     search = matcher False pat
 
--- | @matchSL@ finds the starting indices of all /non-overlapping/ occurrences
+-- | @'matchSL'@ finds the starting indices of all /non-overlapping/ occurrences
 --   of the pattern in the target string. It is an alias for
 --   'Data.ByteString.Lazy.Search.KMP.nonOverlappingIndices'.
 {-# INLINE matchSL #-}

File Data/ByteString/Search/KMP.hs

 -- pattern, the auxiliary data will be computed only once, allowing for
 -- efficient re-use.
 
--- | @indices@ finds the starting indices of all possibly overlapping
+-- | @'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]@.
 {-# INLINE indices #-}
         -> [Int]            -- ^ Offsets of matches
 indices = indicesS
 
--- | @nonOverlappingIndices@ finds the starting indices of all
+-- | @'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'.

File Data/ByteString/Search/KarpRabin.hs

 -- In summary, this module is more of an interesting curiosity than anything
 -- else.
 
--- | @indicesOfAny@ finds all occurrences of any of several non-empty patterns
+-- | @'indicesOfAny'@ finds all occurrences of any of several non-empty patterns
 --   in a strict target string. If no non-empty patterns are given,
 --   the result is an empty list. Otherwise the result list contains
 --   the pairs of all indices where any of the (non-empty) patterns start

File Data/ByteString/Search/Substitution.hs

 --   on ByteStrings. Instances for strict and lazy ByteStrings are
 --   provided here.
 class Substitution a where
-    -- | @substitution@ transforms a value to a substitution function.
+    -- | @'substitution'@ transforms a value to a substitution function.
     substitution :: a -> ([S.ByteString] -> [S.ByteString])
     {-# INLINE substitution #-}
-    -- | @prependCycle sub lazyBS@ shall prepend infinitely many copies
+    -- | @'prependCycle' 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.
     --

File stringsearch.cabal

 -- The package version. See the Haskell package versioning policy
 -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for
 -- standards guiding when and how versions should be incremented.
-Version:             0.3.6
+Version:             0.3.6.1
 
 Homepage:            https://bitbucket.org/dafis/stringsearch
 Bug-reports:         https://bitbucket.org/dafis/stringsearch/issues