Help | Examples | About | API | Blog | Hackage | Haskell
Concurrently search more than 6377 packages and more than 599194 functions! (Index generated: Tue, 22 Apr 2014 14:04:47 UTC )
Found 563 functions, 15 packages and 49 completions.
Replaces/Enhances Text.Regex
Interface API for regex-posix,pcre,parsec,tdfa,dfa No changelog available
Christopher Kuklewicz
Replaces/Enhances Text.Regex
The posix regex backend for regex-base No changelog available
Christopher Kuklewicz
Replaces/Enhances Text.Regex
One module layer over regex-posix to replace Text.Regex No changelog available
Christopher Kuklewicz
Replaces/Enhances Text.Regex
A new all Haskell tagged DFA regex engine, inspired by libtre No changelog available
Christopher Kuklewicz
Replaces/Enhances Text.Regex
The PCRE backend to accompany regex-base, with bundled code from www.pcre.org No changelog available
Audrey Tang
Replaces/Enhances Text.Regex
The PCRE backend to accompany regex-base, see www.pcre.org No changelog available
Christopher Kuklewicz
Unicode Support version of Text.Regex, using regex-tdfa
One module layer over regex-tdfa to replace Text.Regex. regex-compat can't use Unicode characters correctly because of using regex-posix. This is not good for Unicode users. I modified regex-compat to use regex-tdfa for solving today's problem. No changelog available
Christopher Kuklewicz
Replaces/Enhances Text.Regex
Deprecated in favor of regex-pderiv Regex algorithm implementation using partial derivatives No changelog available
Kenny Zhuo Ming Lu and Martin Sulzmann
A quasiquoter for PCRE regexes.
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/ . No changelog available
Matt Morrow
Replaces/Enhances Text.Regex
The TRE backend to accompany regex-base No changelog available
Christopher Kuklewicz
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.

Powered by Haskell, HXT, Snap, and
Please send any feedback to hayoo@holumbus.org