-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | PCRE regex funs
--   
--   Convenience functions to search, replace, format String | ByteString
--   with PCRE regex
@package regex-do
@version 1.0


-- | reexport common types from <a>Text.Regex.PCRE</a>
module Regexdo.TypeRegex

-- | A compiled regular expression
data Regex :: *

-- | 0 based array, with 0th index indicating the full match. If the full
--   match location is not available, represent as (0,0).
type MatchArray = Array Int (MatchOffset, MatchLength)
newtype CompOption :: *
CompOption :: CInt -> CompOption
data ExecOption :: *

module Regexdo.Pcre.Option
data Comp

-- | <a>compBlank</a>
Blank :: Comp

-- | <a>compAnchored</a>
Anchored :: Comp

-- | <a>compCaseless</a>
Caseless :: Comp

-- | <a>compDotAll</a>
Dotall :: Comp

-- | <a>compMultiline</a>
Multiline :: Comp

-- | <a>compUTF8</a>
Utf8 :: Comp

-- | <a>compUngreedy</a>
Ungreedy :: Comp
data Exec

-- | <a>execBlank</a>
BlankE :: Exec

-- | <a>execNotEmpty</a>
NotEmpty :: Exec

-- | <a>execPartial</a>
Partial :: Exec
comp :: [Comp] -> CompOption
exec :: [Exec] -> ExecOption
instance GHC.Enum.Enum Regexdo.Pcre.Option.Exec
instance GHC.Enum.Enum Regexdo.Pcre.Option.Comp

module Regexdo.Convert

-- | both Ascii and Utf8
toByteString :: String -> ByteString

-- | both Ascii and Utf8
toString :: ByteString -> String

module Regexdo.TypeDo
type GroupReplacer acc = MatchArray -> acc -> acc
data Needle n
Needle :: n -> Needle n
data Haystack h
Haystack :: h -> Haystack h
data Replacement r
Replacement :: r -> Replacement r
type PosLen = (MatchOffset, MatchLength)
instance GHC.Base.Functor Regexdo.TypeDo.Replacement
instance GHC.Base.Functor Regexdo.TypeDo.Haystack
instance GHC.Base.Functor Regexdo.TypeDo.Needle

module Regexdo.Pcre.Match

-- | see <a>Regexdo.Pcre.Result</a> for funs converting <a>MatchArray</a>
--   to something useful
--   
--   <a>match</a> returns the first occurence - if any
class Match_ctr n h => Match_cl n h where match r0 (Haystack b0) = matchOnce (r_ r0) b0 matchTest r0 (Haystack b0) = matchTest (r_ r0) b0 matchAll r0 (Haystack b0) = matchAll (r_ r0) b0
match :: Match_cl n h => Needle n -> Haystack h -> Maybe MatchArray
matchTest :: Match_cl n h => Needle n -> Haystack h -> Bool
matchAll :: Match_cl n h => Needle n -> Haystack h -> [MatchArray]

-- | tweak Regex with options
makeRegexOpts :: Match_opt n => [Comp] -> [Exec] -> Needle n -> Regex

-- | this instance accepts regex <a>String</a>
--   
--   <pre>
--   &gt;&gt;&gt; matchTest (Needle "^ab") (Haystack "abc")
--   </pre>
--   
--   True

-- | this instance accepts regex <a>String</a>

-- | this instance accepts regex <a>ByteString</a>

-- | this instance accepts regex <a>ByteString</a>

-- | this instance accepts <a>Regex</a> made with <a>makeRegexOpts</a>

-- | this instance accepts <a>Regex</a> made with <a>makeRegexOpts</a>
class Needle_ r
r_ :: Needle_ r => Needle r -> Regex

-- | _ctr: constraint
type Match_ctr n h = (Extract h, Needle_ n, RegexLike Regex h)
type Match_opt n = RegexMaker Regex CompOption ExecOption n
instance Regexdo.Pcre.Match.Match_cl GHC.Base.String GHC.Base.String
instance Regexdo.Pcre.Match.Match_cl GHC.Base.String Data.ByteString.Internal.ByteString
instance Regexdo.Pcre.Match.Match_cl Data.ByteString.Internal.ByteString Data.ByteString.Internal.ByteString
instance Regexdo.Pcre.Match.Match_cl Data.ByteString.Internal.ByteString GHC.Base.String
instance Regexdo.Pcre.Match.Match_cl Text.Regex.PCRE.Wrap.Regex GHC.Base.String
instance Regexdo.Pcre.Match.Match_cl Text.Regex.PCRE.Wrap.Regex Data.ByteString.Internal.ByteString
instance Regexdo.Pcre.Match.Needle_ Data.ByteString.Internal.ByteString
instance Regexdo.Pcre.Match.Needle_ GHC.Base.String
instance Regexdo.Pcre.Match.Needle_ Text.Regex.PCRE.Wrap.Regex

module Regexdo.Pcre.Result
poslen :: Functor f => f MatchArray -> f [PosLen]

-- | all matches
value :: (Functor f, Extract a) => Haystack a -> f MatchArray -> f [a]

-- | extracts all values in a MatchArray (matched group)
oneMatchArray :: Extract a => Haystack a -> MatchArray -> [a]

-- | extract takes an offset and length and has a default implementation of
--   <tt>extract (off,len) source = before len (after off source)</tt>
extract :: Extract source => (Int, Int) -> source -> source


-- | from stringsearch package
--   
--   this module uses newtypes for args plus function names are tweaked
--   
--   regex is treated as ordinary String. Do not use regex.
module Regexdo.Search

-- | lose needle
--   
--   <pre>
--   &gt;&gt;&gt; break (Needle ":") (Haystack "0123:oid:90")
--   </pre>
--   
--   ("0123", "oid:90")
--   
--   <pre>
--   &gt;&gt;&gt; break (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ("a", "bc\nde")
break :: Needle ByteString -> Haystack ByteString -> (ByteString, ByteString)

-- | (front, needle + end)
--   
--   <pre>
--   &gt;&gt;&gt; breakFront (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ("a", "\nbc\nde")
breakFront :: Needle ByteString -> Haystack ByteString -> (ByteString, ByteString)

-- | (front + needle, end)
--   
--   <pre>
--   &gt;&gt;&gt; breakEnd (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ("a\n", "bc\nde")
breakEnd :: Needle ByteString -> Haystack ByteString -> (ByteString, ByteString)

-- | <pre>
--   &gt;&gt;&gt; replace (Needle "\n") (Replacement ",") (Haystack "a\nbc\nde")
--   </pre>
--   
--   "a,bc,de"
replace :: Needle ByteString -> Replacement ByteString -> Haystack ByteString -> ByteString

-- | <pre>
--   &gt;&gt;&gt; split (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ["a", "bc", "de"]
--   
--   <pre>
--   &gt;&gt;&gt; split (Needle " ") (Haystack "a bc de")
--   </pre>
--   
--   ["a", "bc", "de"]
--   
--   <pre>
--   &gt;&gt;&gt; split (Needle "\\s") (Haystack "abc de fghi ")
--   </pre>
--   
--   ["abc de fghi "]
split :: Needle ByteString -> Haystack ByteString -> [ByteString]

-- | <pre>
--   &gt;&gt;&gt; splitEnd (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ["a\n", "bc\n", "de"]
splitEnd :: Needle ByteString -> Haystack ByteString -> [ByteString]

-- | <pre>
--   &gt;&gt;&gt; splitFront (Needle "\n") (Haystack "a\nbc\nde")
--   </pre>
--   
--   ["a", "\nbc", "\nde"]
splitFront :: Needle ByteString -> Haystack ByteString -> [ByteString]

module Regexdo.Format

-- | pad String with Char to total length of Int
--   
--   <pre>
--   &gt;&gt;&gt; pad '-' 5 "abc"
--   "--abc"
--   </pre>
pad :: Char -> Int -> String -> String
class Format a
format :: Format a => String -> a -> String
instance Regexdo.Format.Format [GHC.Base.String]
instance Regexdo.Format.Format [(GHC.Base.String, GHC.Base.String)]

module Regexdo.Pcre.Replace
data ReplaceCase
Once :: ReplaceCase
All :: ReplaceCase
Utf8 :: ReplaceCase
Multiline :: ReplaceCase
class Replace_cl a
replace :: Replace_cl a => [ReplaceCase] -> (Needle a, Replacement a) -> Haystack a -> a

-- | <h2>dynamic group replace</h2>
--   
--   custom replacer fn returns replacement value
--   
--   <pre>
--   &gt;&gt;&gt; replacer::GroupReplacer String
--       replacer marr1 acc1 = case val1 of
--                              "101" -&gt; fn1 "[A]"
--                              "3" -&gt; fn1 "[Be]"
--       where ol1 = marr1 ! 3 :: (MatchOffset, MatchLength)
--             val1 = extract ol1 acc1
--             fn1 str1 = replaceMatch ol1 (str1,acc1)
--   </pre>
--   
--   see <a>extract</a>
--   
--   below test compares <a>Once</a> vs <a>All</a> options
--   
--   <pre>
--   &gt;&gt;&gt; groupReplace::IO()
--       groupReplace =  hspec $ do
--           describe "Pcre.Replace group" $ do
--               it "Once" $ do
--                  runFn1 [Once] `shouldBe` "a=[A] b=3 12"
--               it "All" $ do
--                  runFn1 [All] `shouldBe` "a=[A] b=[Be] 12"
--               where runFn1 opts1 =
--                        let   rx1 = Needle "(\\w)(=)(\\d{1,3})"
--                              body1 = Haystack "a=101 b=3 12"
--                        in replaceGroup opts1 (rx1,replacer) body1
--   </pre>
replaceGroup :: Mm a => [ReplaceCase] -> (Needle a, GroupReplacer a) -> Haystack a -> a

-- | use in your custom <a>GroupReplacer</a> passed to <a>replaceGroup</a>
--   
--   see example replacer above
replaceMatch :: Replace_cl' a => (MatchOffset, MatchLength) -> (a, a) -> a
instance GHC.Classes.Eq Regexdo.Pcre.Replace.ReplaceCase
instance Regexdo.Pcre.Replace.Replace_cl GHC.Base.String
instance Regexdo.Pcre.Replace.Replace_cl' GHC.Base.String
instance Regexdo.Pcre.Replace.Replace_cl Data.ByteString.Internal.ByteString
instance Regexdo.Pcre.Replace.Replace_cl' Data.ByteString.Internal.ByteString

module Regexdo.Trim

-- | removes leading and trailing spaces and tabs
class Trim a
trim :: Trim a => a -> a
instance Regexdo.Trim.Trim Data.ByteString.Internal.ByteString
instance Regexdo.Trim.Trim GHC.Base.String