+For simplest use of the new API: import Text.Regex.Lazy and one of +
+import Text.Regex.PCRE((=~),(=~~)) +import Text.Regex.Parsec((=~),(=~~)) +import Text.Regex.DFA((=~),(=~~)) +import Text.Regex.PosixRE((=~),(=~~)) +import Text.Regex.TRE((=~),(=~~)) ++The things you can demand of (=~) and (=~~) are all +instance defined in Text.Regex.Impl.Context and they are used +in Example.hs as well. +
+
+You can redefine (=~) and (=~~) to use different options by using makeRegexOpts: +
+(=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target) => source1 -> source -> target +(=~) x r = let q :: Regex + q = makeRegexOpts (some compoption) (some execoption) r + in match q x + +(=~~) ::(RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,Monad m) => source1 -> source -> m target +(=~~) x r = let q :: Regex + q = makeRegexOpts (some compoption) (some execoption) r + in matchM q x ++There is a medium level API with functions compile/execute/regexec in +all the Text.Regex.*.(String|ByteString) modules. These allow for +errors to be reported as Either types when compiling or running. +
+The low level APIs are in the Text.Regex.*.Wrap modules. For the +c-library backends these expose most of the c-api in wrap* functions +that make the type more Haskell-like: CString and CStingLen and +newtypes to specify compile and execute options. The actual foreign +calls are not exported; it does not export the raw c api. +
+Also, Text.Regex.PCRE.Wrap will let you query if it was compiled with +UTF8 suppor: configUTF8 :: Bool. But I do not provide a way +to marshall to or from UTF8. (If you have a UTF8 ByteString then you +would probably be able to make it work, assuming the indices PCRE uses +are in bytes, otherwise look at the wrap* functions which are a thin +layer over the pcreapi). +
+ +
+The old Text.Regex API is can be replaced. If you need to be drop in +compatible with Text.Regex then you can +import Text.Regex.New and report any infidelities as bugs. + +Some advantages of Text.Regex.Parsec over Text.Regex: +
+Internally it uses Parsec to turn the string regex into +a Pattern data type, simplify the Pattern, then +transform the Pattern into a Parsec parser that +accepts matching strings and stores the sub-strings of parenthesized +groups. +
+All of this was motivated by the inability to use Text.Regex +to complete +the regex-dna +benchmark on The +Computer Language Shootout. The current entry there, by Don +Stewart and Alson Kemp and Chris Kuklewicz, does not use this Parsec +solution, but rather a custom DFA lexer from the CTK library. + + diff --git a/examples/Example.hs b/examples/Example.hs new file mode 100644 --- /dev/null +++ b/examples/Example.hs @@ -0,0 +1,14 @@ +{-# OPTIONS_GHC -fglasgow-exts #-} +import Text.Regex.Base +import Text.Regex.Posix((=~),(=~~)) -- or DFA or PCRE or PosixRE +import qualified Data.ByteString.Char8 as B(ByteString,pack) + +main = let b :: Bool + b = ("abaca" =~ "(.)a") + c :: [MatchArray] + c = ("abaca" =~ "(.)a") + d :: Maybe (String,String,String,[String]) + d = ("abaca" =~~ "(.)a") + in do print b + print c + print d diff --git a/examples/Example2.hs b/examples/Example2.hs new file mode 100644 --- /dev/null +++ b/examples/Example2.hs @@ -0,0 +1,44 @@ +{-# OPTIONS_GHC -fglasgow-exts #-} +import Text.Regex.Base +import Text.Regex.Posix(Regex,(=~),(=~~)) -- or DFA or PCRE or PosixRE +import qualified Data.ByteString.Char8 as B(ByteString,pack) + +-- Show mixing of ByteString and String as well as polymorphism: + +main = let x :: (RegexContext Regex String target) => target + x = ("abaca" =~ B.pack "(.)a") + x' :: (RegexContext Regex String target,Monad m) => m target + x' = ("abaca" =~~ "(.)a") + y :: (RegexContext Regex B.ByteString target) => target + y = (B.pack "abaca" =~ "(.)a") + y' :: (RegexContext Regex B.ByteString target,Monad m) => m target + y' = (B.pack "abaca" =~~ B.pack "(.)a") + in do print (x :: Bool) + print (x :: Int) + print (x :: [MatchArray]) + print (x' :: Maybe (String,String,String,[String])) + print (y :: Bool) + print (y :: Int) + print (y :: [MatchArray]) + print (y' :: Maybe (B.ByteString,B.ByteString,B.ByteString,[B.ByteString])) + +{- Output is, except for replacing Full with DFA (which has no capture) +True +2 +[array (0,1) [(0,(1,2)),(1,(1,1))],array (0,1) [(0,(3,2)),(1,(3,1))]] +Just ("a","ba","ca",["b"]) +True +2 +[array (0,1) [(0,(1,2)),(1,(1,1))],array (0,1) [(0,(3,2)),(1,(3,1))]] +Just ("a","ba","ca",["b"]) +-} +{- The output for DFA is +True +2 +[array (0,0) [(0,(1,2))],array (0,0) [(0,(3,2))]] +Just ("a","ba","ca",[]) +True +2 +[array (0,0) [(0,(1,2))],array (0,0) [(0,(3,2))]] +Just ("a","ba","ca",[]) +-} diff --git a/examples/Example3.lhs b/examples/Example3.lhs new file mode 100644 --- /dev/null +++ b/examples/Example3.lhs @@ -0,0 +1,21 @@ +> {-# OPTIONS_GHC -fglasgow-exts #-} + +> import Text.Regex.Base + +> import qualified Text.Regex.PCRE as R +> import qualified Text.Regex.PosixRE as S +> import qualified Text.Regex.Parsec as F + +Choose which library to use depending on presence of PCRE library. + +> (=~) :: (RegexMaker R.Regex R.CompOption R.ExecOption a,RegexContext R.Regex b t +> ,RegexMaker F.Regex F.CompOption F.ExecOption a,RegexContext F.Regex b t +> ,RegexMaker S.Regex S.CompOption S.ExecOption a,RegexContext S.Regex b t) +> => b -> a -> t +> (=~) = case R.getVersion of +> Just _ -> (R.=~) +> Nothing -> case S.getVersion of +> Just _ -> (S.=~) +> Nothing -> (F.=~) + +> main = print ("abc" =~ "(.)c" :: Bool) diff --git a/prologue.txt b/prologue.txt new file mode 100644 --- /dev/null +++ b/prologue.txt @@ -0,0 +1,1 @@ +Interfaces for regular expressions diff --git a/regex-base.cabal b/regex-base.cabal --- a/regex-base.cabal +++ b/regex-base.cabal @@ -2,7 +2,7 @@ -- To fix for cabal < 1.1.4 comment out the Extra-Source-Files line -- **************************************************************** Name: regex-base -Version: 0.72.0.1 +Version: 0.72.0.2 -- Cabal-Version: >=1.1.4 License: BSD3 License-File: LICENSE