Text.RE.TDFA.ByteString.Lazy

Tutorial

We have a regex tutorial at http://tutorial.regex.uk.

The Matches and Match Operators

(*=~) :: ByteString -> RE -> Matches ByteString

find all the matches in the argument text; e.g., to count the number of naturals in s:

countMatches $ s *=~ [re|[0-9]+|]

(?=~) :: ByteString -> RE -> Match ByteString

find the first match in the argument text; e.g., to test if there is a natural number in the input text:

matched $ s ?=~ [re|[0-9]+|]

The SearchReplace Operators

(*=~/) :: ByteString -> SearchReplace RE ByteString -> ByteString

search and replace all matches in the argument text; e.g., this section will convert every YYYY-MM-DD format date in its argument text into a DD/MM/YYYY date:

(*=~/ [ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})///${d}/${m}/${y}|])

(?=~/) :: ByteString -> SearchReplace RE ByteString -> ByteString

search and replace the first occurrence only (if any) in the input text e.g., to prefix the first string of four hex digits in the input text, if any, with 0x:

(?=~/ [ed|[0-9A-Fa-f]{4}///0x$0|])

The Matches Type

data Matches a

the result of matching a RE against a text (with *=~), retaining the text that was matched against

Instances

Functor Matches

Methods

fmap :: (a -> b) -> Matches a -> Matches b

(<$) :: a -> Matches b -> Matches a

(RegexContext regex source [MatchText source], RegexLike regex source) => RegexContext regex source (Matches source)

this instance hooks Matches into regex-base: regex consumers need not worry about any of this

Methods

match :: regex -> source -> Matches source

matchM :: Monad m => regex -> source -> m (Matches source)

Eq a => Eq (Matches a)

Methods

(==) :: Matches a -> Matches a -> Bool

(/=) :: Matches a -> Matches a -> Bool

Show a => Show (Matches a)

Methods

showsPrec :: Int -> Matches a -> ShowS

show :: Matches a -> String

showList :: [Matches a] -> ShowS

matchesSource :: Matches a -> a

the source text being matched

allMatches :: Matches a -> [Match a]

all Match instances found, left to right

anyMatches :: Matches a -> Bool

tests whether the RE matched the source text at all

countMatches :: Matches a -> Int

count the matches

matches :: Matches a -> [a]

list the texts that Matched

The Match Type

data Match a

the result of matching a RE to a text once (with ?=~), retaining the text that was matched against

Instances

Functor Match

Methods

fmap :: (a -> b) -> Match a -> Match b

(<$) :: a -> Match b -> Match a

(RegexContext regex source (AllTextSubmatches (Array Int) (source, (Int, Int))), RegexLike regex source) => RegexContext regex source (Match source)

this instance hooks Match into regex-base: regex consumers need not worry about any of this

Methods

match :: regex -> source -> Match source

matchM :: Monad m => regex -> source -> m (Match source)

Eq a => Eq (Match a)

Methods

(==) :: Match a -> Match a -> Bool

(/=) :: Match a -> Match a -> Bool

Show a => Show (Match a)

Methods

showsPrec :: Int -> Match a -> ShowS

show :: Match a -> String

showList :: [Match a] -> ShowS

matchSource :: Match a -> a

the whole source text

matched :: Match a -> Bool

tests whether the RE matched the source text at all

matchedText :: Match a -> Maybe a

yields the text matched by the RE, Nothing if no match

The Macros and Parsers

There are a number of RE macros and corresponding Haskell parsers for parsing the matched text into appropriate Haskell types. See the Macros Tables for details.

module Text.RE.TestBench.Parsers

The RE Type

data RE

the RE type for this back end representing a well-formed, compiled RE

Instances

IsOption REOptions

Methods

makeREOptions :: REOptions -> REOptions

IsOption (Macros RE)

Methods

makeREOptions :: Macros RE -> REOptions

reSource :: RE -> String

extract the RE source string from the RE

Options

You can specify different compilation options by appending a to the name of an [re| ... |] or [ed| ... /// ... |] quasi quoter to select the corresponding compilation option. For example, the section,

(?=~/ [edBlockInsensitive|foo$///bar|])

will replace a foo suffix of the argument text, of any capitalisation, with a (lower case) bar. If you need to specify the options dynamically, use the [re_| ... |] and [ed_| ... /// ... |] quasi quoters, which generate functions that take an IsOption option (e.g., a SimpleReOptions value) and yields a RE or SearchReplace as apropriate. For example if you have a SimpleReOptions value in sro then

(?=~/ [ed_|foo$///bar|] sro)

will compile the foo$ RE according to the value of sro. For more on specifying RE options see Text.RE.REOptions.

data SimpleREOptions

the default API uses these simple, universal RE options, which get auto-converted into the apropriate back-end REOptions_

Constructors

MultilineSensitive

case-sensitive with ^ and $ matching the start and end of a line

MultilineInsensitive

case-insensitive with ^ and $ matsh the start and end of a line

BlockSensitive

case-sensitive with ^ and $ matching the start and end of the input text

BlockInsensitive

case-insensitive with ^ and $ matching the start and end of the input text

Instances

Bounded SimpleREOptions

Methods

minBound :: SimpleREOptions

maxBound :: SimpleREOptions

Enum SimpleREOptions

Methods

succ :: SimpleREOptions -> SimpleREOptions

pred :: SimpleREOptions -> SimpleREOptions

toEnum :: Int -> SimpleREOptions

fromEnum :: SimpleREOptions -> Int

enumFrom :: SimpleREOptions -> [SimpleREOptions]

enumFromThen :: SimpleREOptions -> SimpleREOptions -> [SimpleREOptions]

enumFromTo :: SimpleREOptions -> SimpleREOptions -> [SimpleREOptions]

enumFromThenTo :: SimpleREOptions -> SimpleREOptions -> SimpleREOptions -> [SimpleREOptions]

Eq SimpleREOptions

Methods

(==) :: SimpleREOptions -> SimpleREOptions -> Bool

(/=) :: SimpleREOptions -> SimpleREOptions -> Bool

Ord SimpleREOptions

Methods

compare :: SimpleREOptions -> SimpleREOptions -> Ordering

(<) :: SimpleREOptions -> SimpleREOptions -> Bool

(<=) :: SimpleREOptions -> SimpleREOptions -> Bool

(>) :: SimpleREOptions -> SimpleREOptions -> Bool

(>=) :: SimpleREOptions -> SimpleREOptions -> Bool

max :: SimpleREOptions -> SimpleREOptions -> SimpleREOptions

min :: SimpleREOptions -> SimpleREOptions -> SimpleREOptions

Show SimpleREOptions

Methods

showsPrec :: Int -> SimpleREOptions -> ShowS

show :: SimpleREOptions -> String

showList :: [SimpleREOptions] -> ShowS

Lift SimpleREOptions

we need to use this in the quasi quoters to specify SimpleREOptions selected by the quasi quoter

Methods

lift :: SimpleREOptions -> Q Exp

IsOption SimpleREOptions

Methods

makeREOptions :: SimpleREOptions -> REOptions

Compiling and Escaping REs

data SearchReplace re s

contains a compiled RE and replacement template

Constructors

SearchReplace

Fields

• getSearch :: !re

  the RE to match a string to replace

• getTemplate :: !s

  the replacement template with ${cap} used to identify a capture (by number or name if one was given) and $$ being used to escape a single $

Instances

Functor (SearchReplace re)

Methods

fmap :: (a -> b) -> SearchReplace re a -> SearchReplace re b

(<$) :: a -> SearchReplace re b -> SearchReplace re a

(Show s, Show re) => Show (SearchReplace re s)

Methods

showsPrec :: Int -> SearchReplace re s -> ShowS

show :: SearchReplace re s -> String

showList :: [SearchReplace re s] -> ShowS

compileRegex :: (Functor m, Monad m) => String -> m RE

compile a String into a RE with the default options, generating an error if the RE is not well formed

compileRegexWith :: (Functor m, Monad m) => SimpleREOptions -> String -> m RE

compile a String into a RE using the given SimpleREOptions, generating an error if the RE is not well formed

compileSearchReplace :: (Monad m, Functor m, IsRegex RE s) => String -> String -> m (SearchReplace RE s)

compile a SearchReplace template generating errors if the RE or the template are not well formed, all capture references being checked

compileSearchReplaceWith :: (Monad m, Functor m, IsRegex RE s) => SimpleREOptions -> String -> String -> m (SearchReplace RE s)

compile a SearchReplace template, with simple options, generating errors if the RE or the template are not well formed, all capture references being checked

escape :: (Functor m, Monad m) => (String -> String) -> String -> m RE

convert a string into a RE that matches that string, and apply it to an argument continuation function to make up the RE string to be compiled; e.g., to compile a RE that will only match the string:

maybe undefined id . escape (("^"++) . (++"$"))

escapeWith :: (Functor m, Monad m) => SimpleREOptions -> (String -> String) -> String -> m RE

a variant of escape where the SimpleREOptions are specified

escapeREString :: String -> String

Convert a string into a regular expression that will match that string

The Classic regex-base Match Operators

(=~) :: (Typeable a, RegexContext Regex ByteString a) => ByteString -> RE -> a

the `regex-base` polymorphic match operator

(=~~) :: (Monad m, Functor m, Typeable a, RegexContext Regex ByteString a) => ByteString -> RE -> m a

the `regex-base` monadic, polymorphic match operator

The re Quasi Quoters

The [re|.*|] quasi quoters, with variants for specifing different options to the RE compiler (see Text.RE.REOptions), and the specialised back-end types and functions.

re :: QuasiQuoter

[re| ... |], is equivalent to [reMultilineSensitive| ... |], compiling a case-sensitive, multi-line RE

reMultilineSensitive :: QuasiQuoter

[reMultilineSensitive| ... |], compiles a case-sensitive, multi-line RE

reMultilineInsensitive :: QuasiQuoter

[reMultilineInsensitive| ... |], compiles a case-insensitive, multi-line RE

reBlockSensitive :: QuasiQuoter

[reMultilineInsensitive| ... |], compiles a case-sensitive, non-multi-line RE

reBlockInsensitive :: QuasiQuoter

[reMultilineInsensitive| ... |], compiles a case-insensitive, non-multi-line RE

reMS :: QuasiQuoter

[reMS| ... |] is a shorthand for [reMultilineSensitive| ... |]

reMI :: QuasiQuoter

[reMI| ... |] is a shorthand for [reMultilineInsensitive| ... |]

reBS :: QuasiQuoter

[reBS| ... |] is a shorthand for [reBlockSensitive| ... |]

reBI :: QuasiQuoter

[reBI| ... |] is a shorthand for [reBlockInsensitive| ... |]

re_ :: QuasiQuoter

[re_| ... |] compiles a RE to produce a function that takes the RE options (e.g., a SimpleREOptions value) and yields the RE compiled with those options. For example,

countMatches $ s *=~ [re_|[0-9a-f]+|] MultilineInsensitive

counts the number of hexadecimal digit strings in s, allowing for upper- or lower-case hex didgits (which is entirely equivalent in this example to just using [reMultilineInsensitive|[0-9a-f]+|]).

The Ed Quasi Quoters

The [ed|.*///foo|] quasi quoters, with variants for specifing different options to the RE compiler (see Text.RE.REOptions).

edMultilineSensitive :: QuasiQuoter

[edMultilineSensitive| ... /// ... |] compiles a case-sensitive, multi-line SearchReplace template

edMultilineInsensitive :: QuasiQuoter

[edMultilineInsensitive| ... /// ... |] compiles a case-insensitive, multi-line SearchReplace template

edBlockSensitive :: QuasiQuoter

[edBlockSensitive| ... /// ... |] compiles a case-sensitive, non-multi-line SearchReplace template

edBlockInsensitive :: QuasiQuoter

[edBlockInsensitive| ... /// ... |] compiles a case-insensitive, non-multi-line SearchReplace template

ed :: QuasiQuoter

[ed| ... /// ... |], is equivalent to [edMultilineSensitive| ... /// ... |], compiling a case-sensitive, multi-line SearchReplace

edMS :: QuasiQuoter

[edMS| ... /// ... |] is a shorthand for [edMultilineSensitive| ... /// ... |]

edMI :: QuasiQuoter

[edMI| ... /// ... |] is a shorthand for [edMultilineInsensitive| ... /// ... |]

edBS :: QuasiQuoter

[edBS| ... /// ... |] is a shorthand for [edBlockSensitive| ... /// ... |]

edBI :: QuasiQuoter

[edBI| ... /// ... |] is a shorthand for [edBlockInsensitive| ... /// ... |]

ed_ :: QuasiQuoter

[ed_| ... /// ... |] compiles a SearchReplace template to produce a function that takes the RE options (e.g., a SimpleREOptions value) and yields the SearchReplace template compiled with those options. For example,

s *=~/ [ed_|${hex}([0-9a-f]+)///0x${hex}|] MultilineInsensitive

prefixes the hexadecimal digit strings in s with 0x, allowing for upper- or lower-case hex didgits (which is entirely equivalent in this example to just using [edMultilineInsensitive|[0-9a-f]+|]).

The cp Quasi Quoters

cp :: QuasiQuoter

quasi quoter for CaptureID: [cp|0|], [cp|0|], etc., indexing captures by classic positional numbers, and [cp|foo|], etc., referencing a named capture [re| ... ${foo}( ... ) ... |].

IsRegex

The IsRegex class is used to abstact over the different regex back ends and the text types they work with -- see Text.RE.Tools.IsRegex for details.

module Text.RE.Tools.IsRegex

Orphan instances

IsRegex RE ByteString

Methods

matchOnce :: RE -> ByteString -> Match ByteString

matchMany :: RE -> ByteString -> Matches ByteString

makeRegex :: (Functor m, Monad m) => ByteString -> m RE

makeRegexWith :: (Functor m, Monad m) => SimpleREOptions -> ByteString -> m RE

makeSearchReplace :: (Functor m, Monad m, IsRegex RE ByteString) => ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeSearchReplaceWith :: (Functor m, Monad m, IsRegex RE ByteString) => SimpleREOptions -> ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeEscaped :: (Functor m, Monad m) => (ByteString -> ByteString) -> ByteString -> m RE

makeEscapedWith :: (Functor m, Monad m) => SimpleREOptions -> (ByteString -> ByteString) -> ByteString -> m RE

regexSource :: RE -> ByteString