Text.RE.TDFA

Tutorial

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

About this Module

This module provides access to the back end through polymorphic functions that operate over all of the StringTextByteString types supported by the back end. If you don't need this generality you might want to consider using one of the modules that have been specialised for each of these types:

• Text.RE.TDFA.ByteString
• Text.RE.TDFA.ByteString.Lazy
• Text.RE.ZeInternals.TDFA
• Text.RE.TDFA.Sequence
• Text.RE.TDFA.String
• Text.RE.TDFA.Text
• Text.RE.TDFA.Text.Lazy

The Match Operators

(*=~) :: IsRegex RE s => s -> RE -> Matches s

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

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

(?=~) :: IsRegex RE s => s -> RE -> Match s

find first match in text

The SearchReplace Operators

(*=~/) :: IsRegex RE s => s -> SearchReplace RE s -> s

search and replace all occurrences; e.g., this section will yield a function to convert every a YYYY-MM-DD into a DDMMYYYY:

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

(?=~/) :: IsRegex RE s => s -> SearchReplace RE s -> s

search and replace the first occurrence only

The Classic rexex-base Match Operators

(=~) :: (RegexContext Regex s a, RegexMaker Regex CompOption ExecOption s) => s -> RE -> a

the regex-base polymorphic match operator

(=~~) :: (Monad m, RegexContext Regex s a, RegexMaker Regex CompOption ExecOption s) => s -> RE -> m a

the regex-base monadic, polymorphic match operator

Matches

data Matches a

the result type to use when every match is needed, not just the first match of the RE against the source

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 Matches

Match

data Match a

the result of matching a RE to a text once, listing the text that was matched and the named captures in the RE and all of the substrings matched, with the text captured by the whole RE; a complete failure to match will be represented with an empty array (with bounds (0,-1))

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

tests whether the RE matched the source text at all

The RE Type and Functions

data RE

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

Instances

IsOption REOptions RE CompOption ExecOption

Methods

makeREOptions :: REOptions -> REOptions_ RE CompOption ExecOption

IsOption (Macros RE) RE CompOption ExecOption

Methods

makeREOptions :: Macros RE -> REOptions_ RE CompOption ExecOption

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

reSource :: RE -> String

extract the RE source string from the RE

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

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

escapeWith :: (Functor m, Monad m) => SimpleREOptions -> (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 with the default options

escapeREString :: String -> String

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

module Text.RE.ZeInternals.TDFA

The [ed| ... |] quasi quoters

ed :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edMS :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edMI :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edBS :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edBI :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edMultilineSensitive :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edMultilineInsensitive :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edBlockSensitive :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

edBlockInsensitive :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

ed_ :: QuasiQuoter

the [ed| ... /// ... |] quasi quoters

The Operator Instances

These modules merely provide the IsRegex instances.

module Text.RE.TDFA.ByteString

module Text.RE.TDFA.ByteString.Lazy

module Text.RE.TDFA.Sequence

module Text.RE.TDFA.String

module Text.RE.TDFA.Text

module Text.RE.TDFA.Text.Lazy