regex-base 0.72.0.1 → 0.72.0.2
raw patch · 9 files changed
+274/−3 lines, 9 filesnew-uploaderPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
Files
- Text/Regex/Base.hs +1/−2
- doc/README +39/−0
- doc/Redesign.txt +14/−0
- doc/lazy.html +139/−0
- examples/Example.hs +14/−0
- examples/Example2.hs +44/−0
- examples/Example3.lhs +21/−0
- prologue.txt +1/−0
- regex-base.cabal +1/−1
Text/Regex/Base.hs view
@@ -44,8 +44,7 @@ module Text.Regex.Base ( -- | RegexLike defines classes and type, and 'Extract' instances module Text.Regex.Base.RegexLike- -- | Context only exports instances for 'RegexContext'- ,module Text.Regex.Base.Context) where+ ) where import Text.Regex.Base.RegexLike import Text.Regex.Base.Context
+ doc/README view
@@ -0,0 +1,39 @@+README for TestRegexLazy-0.66++By Chris Kuklewicz (TextRegexLazy (at) personal (dot) mightyreason (dot) com)++For more detail on Text.Regex.Lazy look at the very very outdated+lazy.html file or the LICENSE file.++To build and install:+ get Data.ByteString from http://www.cse.unsw.edu.au/~dons/fps.html+ (You probably want to configure ByteString's cabal with -p for profiling)+ edit list of BACKENDS in Makefile if you want to exclude regex-tre or regex-pcre+ edit regex-pcre/regex-pcre.cabal to point to your PCRE installation+ edit CONF and USER variables in Makefile to point to your setup+ (The CONF includes -p for profiling)+ run "make all" which will create and install all the packages in $(SUBDIRS)++The packages:+ regex-base : This hold the type class definitions and (most) RegexContext,Extract instances+ regex-compat : Builds Text.Regex.New (soon to replace Text.Regex) on top of regex-parsec+ regex-pcre : Build the PCRE backend, http://www.pcre.org/+ regex-posix : Builds the Posix backend+ regex-parsec : Builds my lazy parsec based pure haskell backend+ regex-dfa : Build the simple backend based on CTKLight (this is LGPL)++There is an additional "regex-devel" package where I am setting up+testing and bechmarking. Use "make regex-devel" at the top level to+compile (not install), or use its cabal Setup.hs.+regex-devel/bench/runbench.sh is my simple toy benchmark.++To use =~ and =~~ new API:++> import Text.Regex.(Parsec|DFA|PCRE|PosixRE|TRE)+and perhaps+> import Text.Regex.Base++Look at Example*.hs and instances in Text.Regex.Base.Context.hs for what it can do.++For old "Text.Regex" API drop in compatibility, import Text.Regex.New (uses PosixRE backend)+
+ doc/Redesign.txt view
@@ -0,0 +1,14 @@+The regular expression stuff needs some of a rethink.++Things that could be made more efficient, as I think of them:++(1) Making Arrays in Wrap* may be a bit inefficient+counter: Usage may be like "look up element 3" so random access is good++(2) String DFA: the findRegex computes the prefix string itself, which is sometimes wasted / sometimes wanted / always discarded. Also, the input string at the start of the match is discarded++(3) Lazy computes MatchedStrings array then discards it. Wasteful.++(4) Mighty extend RegexLike with ability to return "strings", i.e. Extract instance. The default conversion could be left in for some things. Then RegexContext could pull from that instead of matchOnce/matchAll.++(5) make RegexLike default matchAll/matchOnce in terms of matchOnceText and matchAllText
+ doc/lazy.html view
@@ -0,0 +1,139 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">+<HTML>+ <head>+ <title>Text.Regex.Lazy</title>+ </head>+<body>+<h1><tt>Text.Regex.Lazy</tt></h1>+<h2>Version 0.70 (2006-08-10)</h2>++<h3>By Chris Kuklewicz (TextRegexLazy (at) personal (dot) mightyreason (dot) com)</h3>++Changes from 0.66 to 0.70+<ul>+ <li> regex-tre added for libtre backend (Text.Regex.TRE), see http://laurikari.net/tre/+ <li> regex-devel added for tests and benchmarks+ <li> Text.Regex.*.Wrap APIs improved: the exported wrap* functions+ never call fail or error under normal circumstances, and use Either+ types to report errors. Allocation failures are reported with fail.+ <li> Text.Regex.*.(ByteString|String) all should export+ compile/execute/regexec functions which report errors using Either.+</ul>++Changes from 0.55 to 0.66+<ul>+ <li> I broke this into many packages, regex-base for the interface and regex-pcre, regex-posix, regex-parsec, regex-dfa for the four backends and regex-compat to replace Text.Regex(.New)+ <li> The top level Makefile now can drive setup and installation of all the packages at once.+</ul>++Changes from 0.44 to 0.55+<ul>+ <li> <b>JRegex has been assimilated: PCRE and PosixRE are here</b>.+ The JRegex-style API rocks, see below and Context.hs and Example.hs+ <li> Haddock seems to run via ./setup haddock, but the documentation is very thin+ <li> ./setup test runs TestTestRegexLazy binary if uncommented in cabal file+ <li> default is now to compile with -Wall -Werror -O2+ <li> You may need to point the cabal file's "Extra-Lib-Dirs" to point to pcre.+ <li> You may or may not need a "-lpcre" option to ghc when building+ projects that depend on Text.Regex.Lazy now.+</ul>++Changes from 0.33 to 0.44+<ul>+ <li> Cabal+ <li> Compile with -Wall -Werror+ <li> Change DFAEngineFPS from Data.FastPackedString to Data.ByteString+</ul>+See the LICENSE file for details on copyright. See README for building instructions.+<br/>+The new API is very close to JRegex and supports 4 backends:+<ul>+ <li> Posix, the standard c regex library+ <li> PCRE, the <a href="http://www.pcre.org/">Perl Compatible Regular Expressions</a> c library+ <li> Full, the lazy Parsec based library (see old api below)+ <li> DFA, the fast lazy matching library (see old api below)+</ul>+And for all backends, there are two types that can be used as a source+of regular expressions or to match a regular expression against:+String, and ByteString. The ByteString library will be in the next+GHC and can be gotten+from <a+href="http://www.cse.unsw.edu.au/~dons/fps.html">http://www.cse.unsw.edu.au/~dons/fps.html</a>.+<p>+For simplest use of the new API: import Text.Regex.Lazy and one of+<pre>+import Text.Regex.PCRE((=~),(=~~))+import Text.Regex.Parsec((=~),(=~~))+import Text.Regex.DFA((=~),(=~~))+import Text.Regex.PosixRE((=~),(=~~))+import Text.Regex.TRE((=~),(=~~))+</pre>+The things you can demand of (=~) and (=~~) are all+instance defined in Text.Regex.Impl.Context and they are used+in <tt>Example.hs</tt> as well.+<p>+<p>+You can redefine (=~) and (=~~) to use different options by using makeRegexOpts:+<pre>+(=~) :: (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+</pre>+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.+<p>+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.+<p>+Also, Text.Regex.PCRE.Wrap will let you query if it was compiled with+UTF8 suppor: <tt>configUTF8 :: Bool</tt>. 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).+<p>++<p>+The old Text.Regex API is can be replaced. If you need to be drop in+compatible with <tt>Text.Regex</tt> then you can+import <tt>Text.Regex.New</tt> and report any infidelities as bugs.++Some advantages of <tt>Text.Regex.Parsec</tt> over <tt>Text.Regex</tt>:+<ul>+ <li> It does not marshal to and from c-code arrays, so it is much+ faster on large input strings.+ <li> It consumes the input <tt>String</tt> in a mostly lazy manner.+ This makes streaming from input to output possible.+ <li> It performs sanity checks so that <tt>subRegex</tt>+ and <tt>splitRegex</tt> don't loop or go crazy if the pattern+ matches an empty string -- it will just return the input.+ <li> If the <tt>String</tt> regex does not parse then you get a nicer error+ message.+</ul>+<p>+Internally it uses <tt>Parsec</tt> to turn the string regex into+a <tt>Pattern</tt> data type, simplify the <tt>Pattern</tt>, then+transform the <tt>Pattern</tt> into a <tt>Parsec</tt> parser that+accepts matching strings and stores the sub-strings of parenthesized+groups.+<p>+All of this was motivated by the inability to use <tt>Text.Regex</tt>+to complete+the <a+href="http://shootout.alioth.debian.org/gp4/benchmark.php?test=regexdna&lang=all">regex-dna+benchmark</a> on <a href="http://shootout.alioth.debian.org/">The+Computer Language Shootout</a>. 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.+</body>+</HTML>
+ examples/Example.hs view
@@ -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
+ examples/Example2.hs view
@@ -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",[])+-}
+ examples/Example3.lhs view
@@ -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)
+ prologue.txt view
@@ -0,0 +1,1 @@+Interfaces for regular expressions
regex-base.cabal view
@@ -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