Hayoo! - Haskell API Search

A quasiquoter for Text.Regex.PCRE regexes. This makes use of a new GHC extension known as QuasiQuotes. QuasiQuotes do not appear in ghc until 6.9, BUT there is a patch for ghc-6.8.3 which adds quasiquote functionality. A patched version of ghc-6.8.3, made possible by audreyt's patch, is at http://code.haskell.org/~morrow/quasiquotes/ghc-6.8.3_QQ-0.2.tar.bz2 . An example of the use of regexqq is located at http://code.haskell.org/~morrow/quasiquotes/regexqq.txt . Haddock docs are at http://code.haskell.org/~morrow/quasiquotes/regexqq/docs/ .

Matt Morrow

Text

regex-tre

Replaces/Enhances Text.Regex

The TRE backend to accompany regex-base

Christopher Kuklewicz

Text

regex-pderiv

Replaces/Enhances Text.Regex. Implementing regular expression matching using Antimirov's partial derivatives.

Regex algorithm implementation using partial derivatives. The svn source also shipped with two other referential implementations, e.g. Thomspon NFA and Glushkov NFA. For more detail please check out http: code.google.com p xhaskell-library/

Kenny Zhuo Ming Lu and Martin Sulzmann

Text

regex-parsec

Replaces/Enhances Text.Regex

A better performance, lazy, powerful replacement of Text.Regex and JRegex

Christopher Kuklewicz

Top 15 Modules

Text 594

RegExDot 2

RRegex 1

Database 1

Top 15 Packages

regex-pcre-builtin 89

regex-pcre 89

regex-dfa 69

regex-tdfa 55

regex-pderiv 50

regex-posix 45

pcre-less 35

pcre-light 34

regex-deriv 32

regex-applicative 20

rex 15

regexpr 11

regex-tdfa-text 9

regex-compat-tdfa 8

regex-compat 8

Text.Regex Text.Regex.Applicative Text.Regex.Base Text.Regex.Base.Context Text.Regex.Base.Impl Text.Regex.Base.RegexLike Text.Regex.Base.RegexLike.MatchArray Text.Regex.DFA Text.Regex.DFA.Common Text.Regex.DFA.Engine Text.Regex.DFA.Pattern Text.Regex.DFA.String Text.Regex.DFA.Wrap Text.Regex.Deriv.Parse Text.Regex.Deriv.RE Text.Regex.Deriv.Word Text.Regex.Glob.String Text.Regex.Lazy.DFAEngineFPS Text.Regex.Less Text.Regex.Less.REOpts Text.Regex.Lib.WrapDFAEngine Text.Regex.Literal Text.Regex.PCRE Text.Regex.PCRE.ByteString Text.Regex.PCRE.Light Text.Regex.PCRE.Light.compileM Text.Regex.PCRE.QQ Text.Regex.PCRE.Rex Text.Regex.PCRE.String Text.Regex.PCRE.Wrap Text.Regex.PDeriv.Nfa Text.Regex.PDeriv.RE Text.Regex.Parsec Text.Regex.Posix Text.Regex.Posix.ByteString Text.Regex.Posix.String Text.Regex.Posix.Wrap Text.Regex.TDFA Text.Regex.TDFA.NewDFA.Engine Text.Regex.TDFA.NewDFA.String Text.Regex.TDFA.NewDFA.Tester Text.Regex.TDFA.Pattern Text.Regex.TDFA.TDFA Text.Regex.TDFA.TNFA Text.Regex.TDFA.Text Text.Regex.TDFA.UTF8 Text.Regex.XMLSchema.String.Regex Text.Regex.XXX Text.RegexPR

Text.Regex.Base.	Base	:: module
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 Source
Text.Regex.Posix.	Posix	:: module
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. Source
Text.Regex.	splitRegex	:: Regex -> String -> [String]
regex-compat	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. Source
Text.Regex.	subRegex	:: Regex -> String -> String -> String
regex-compat	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.
Text.Regex.	Regex	:: module
regex-compat	Regular expression matching. Uses the POSIX regular expression interface in Text.Regex.Posix. Source
Text.Regex.	matchRegexAll	:: Regex -> String -> Maybe (String, String, String, [String])
regex-compat	Match a regular expression against a string, returning more information about the match.
Text.Regex.	matchRegex	:: Regex -> String -> Maybe [String]
regex-compat	Match a regular expression against a string
Text.Regex.	mkRegexWithOpts	:: String -> Bool -> Bool -> Regex
regex-compat	Makes a regular expression, where the multi-line and case-sensitive options can be changed from the default settings.
Text.Regex.	mkRegex	:: String -> Regex
regex-compat	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). Source
Text.Regex.	Regex	:: data
regex-compat	A compiled regular expression.