regex-compat - Text.Regex  

Regular expression matching. Uses the POSIX regular expression interface in Text.Regex.Posix.

regex-compat - Text.Regex  

Match a regular expression against a string

matchRegexAll :: Regex-> String-> Maybe (String, String, String, [String])

regex-compat - Text.Regex  

Match a regular expression against a string, returning more information about the match.

regex-compat - Text.Regex  

Makes a regular expression with the default options (multi-line, case-sensitive). The syntax of regular expressions is otherwise that of egrep (i.e. POSIX "extended" regular expressions).

regex-compat - Text.Regex  

Makes a regular expression, where the multi-line and case-sensitive options can be changed from the default settings.

regex-compat - Text.Regex  

Splits a string based on a regular expression. The regular expression should identify one delimiter.

This does not advance and produces an infinite list of [] if the regex matches an empty string. This misfeature is here to match the behavior of the the original Text.Regex API.

subRegex :: Regex-> String-> String-> String

regex-compat - Text.Regex  

Replaces every occurance of the given regexp with the replacement string.

In the replacement string, "\1" refers to the first substring; "\2" to the second, etc; and "\0" to the entire match. "\\\\" will insert a literal backslash.

This does not advance if the regex matches an empty string. This misfeature is here to match the behavior of the the original Text.Regex API.

regex-base - Text.Regex.Base  

Classes and instances for Regex matching.

This module merely imports and re-exports the common part of the new api: Text.Regex.Base.RegexLike and Text.Regex.Base.Context.

To see what result types the instances of RegexContext can produce, please read the Text.Regex.Base.Context haddock documentation.

This does not provide any of the backends, just the common interface they all use. The modules which provide the backends and their cabal packages are:

  • Text.Regex.Posix from regex-posix
  • Text.Regex from regex-compat (uses regex-posix)
  • Text.Regex.Parsec from regex-parsec
  • Text.Regex.DFA from regex-dfa
  • Text.Regex.PCRE from regex-pcre
  • Test.Regex.TRE from regex-tre

In fact, just importing one of the backends is adequate, you do not also need to import this module.

TODO: Copy Example*hs files into this haddock comment

regex-posix - Text.Regex.Posix  

Module that provides the Regex backend that wraps the c posix regex api. This is the backend being used by the regex-compat package to replace Text.Regex

The Text.Regex.Posix module provides a backend for regular expressions. If you import this along with other backends, then you should do so with qualified imports, perhaps renamed for convenience.

If the =~ and =~~ functions are too high level, you can use the compile, regexec, and execute functions from importing either Text.Regex.Posix.String or Text.Regex.Posix.ByteString. If you want to use a low-level CString interface to the library, then import Text.Regex.Posix.Wrap and use the wrap* functions.

This module is only efficient with ByteString only if it is null terminated, i.e. (Bytestring.last bs)==0. Otherwise the library must make a temporary copy of the ByteString and append the NUL byte.

A String will be converted into a CString for processing. Doing this repeatedly will be very inefficient.

Note that the posix library works with single byte characters, and does not understand Unicode. If you need Unicode support you will have to use a different backend.

When offsets are reported for subexpression captures, a subexpression that did not match anything (as opposed to matching an empty string) will have its offset set to the unusedRegOffset value, which is (-1).

Benchmarking shows the default regex library on many platforms is very inefficient. You might increase performace by an order of magnitude by obtaining libpcre and regex-pcre or libtre and regex-tre. If you do not need the captured substrings then you can also get great performance from regex-dfa. If you do need the capture substrings then you may be able to use regex-parsec to improve performance.

regex-tdfa - Text.Regex.TDFA  

The Text.Regex.TDFA module provides a backend for regular expressions. It provides instances for the classes defined and documented in Text.Regex.Base and re-exported by this module. If you import this along with other backends then you should do so with qualified imports (with renaming for convenience).

This regex-tdfa package implements, correctly, POSIX extended regular expressions. It is highly unlikely that the regex-posix package on your operating system is correct, see http:www.haskell.orghaskellwikiRegex_Posix for examples of your OS's bugs.

This package does provide captured parenthesized subexpressions.

Depending on the text being searched this package supports Unicode. The [Char] and (Seq Char) text types support Unicode. The ByteString and ByteString.Lazy text types only support ASCII. It is possible to support utf8 encoded ByteString.Lazy by using regex-tdfa and regex-tdfa-utf8 packages together (required the utf8-string package).

As of version 1.1.1 the following GNU extensions are recognized, all anchors:

\` at beginning of entire text

\' at end of entire text

\< at beginning of word

\> at end of word

\b at either beginning or end of word

\B at neither beginning nor end of word

The above are controlled by the newSyntax Bool in CompOption.

Where the word boundaries means between characters that are and are not in the [:word:] character class which contains [a-zA-Z0-9_]. Note that < and b may match before the entire text and > and b may match at the end of the entire text.

There is no locale support, so collating elements like [.ch.] are simply ignored and equivalence classes like [=a=] are converted to just [a]. The character classes like [:alnum:] are supported over ASCII only, valid classes are alnum, digit, punct, alpha, graph, space, blank, lower, upper, cntrl, print, xdigit, word.

This package does not provide basic regular expressions. This package does not provide back references inside regular expressions.

The package does not provide Perl style regular expressions. Please look at the regex-pcre and pcre-light packages instead.

(=~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target) => source1 -> source -> target

regex-tdfa - Text.Regex.TDFA  

This is the pure functional matching operator. If the target cannot be produced then some empty result will be returned. If there is an error in processing, then error will be called.

(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target

regex-tdfa - Text.Regex.TDFA  

This is the monadic matching operator. If a single match fails, then fail will be called.

regex-base - Text.Regex.Base.Impl  

Helper functions for defining certain instances of RegexContext. These help when defining instances of RegexContext with repeated types:

 instance (RegexLike regex source) => RegexContext regex source source where

runs into overlapping restrictions. To avoid this I have each backend define, for its own Regex type:

 instance RegexContext Regex String String where
   match = polymatch
   matchM = polymatchM
 instance RegexContext Regex ByteString ByteString where
   match = polymatch
   matchM = polymatchM

regex-compat-tdfa - Text.Regex  

Regular expression matching. Uses the POSIX regular expression interface in Text.Regex.TDFA.