Safe Haskell	None
Language	Haskell2010

Text.RE.TDFA

Contents

Tutorial
About this Module
The Match Operators
The SearchReplace Operators
The Classic rexex-base Match Operators
Matches
Match
The RE Type and Functions
The [ed| ... |] quasi quoters
The Operator Instances

Synopsis

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:

The Match Operators

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

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 Source #

find first match in text

The SearchReplace Operators

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

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 Source #

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 Source #

the regex-base polymorphic match operator

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

the regex-base monadic, polymorphic match operator

Matches

data Matches a Source #

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

Instances

Functor Matches Source #
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) 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) Source #
Methods (==) :: Matches a -> Matches a -> Bool # (/=) :: Matches a -> Matches a -> Bool #
Show a => Show (Matches a) Source #
Methods showsPrec :: Int -> Matches a -> ShowS # show :: Matches a -> String # showList :: [Matches a] -> ShowS #

matchesSource :: Matches a -> a Source #

the source text being matched

allMatches :: Matches a -> [Match a] Source #

all Match instances found, left to right

anyMatches :: Matches a -> Bool Source #

tests whether the RE matched the source text at all

countMatches :: Matches a -> Int Source #

count the matches

matches :: Matches a -> [a] Source #

list the Matches

Match

data Match a Source #

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 Source #
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) 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) Source #
Methods (==) :: Match a -> Match a -> Bool # (/=) :: Match a -> Match a -> Bool #
Show a => Show (Match a) Source #
Methods showsPrec :: Int -> Match a -> ShowS # show :: Match a -> String # showList :: [Match a] -> ShowS #

matchSource :: Match a -> a Source #

the whole source text

matched :: Match a -> Bool Source #

tests whether the RE matched the source text at all

matchedText :: Match a -> Maybe a Source #

tests whether the RE matched the source text at all

The `RE` Type and Functions

data RE Source #

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

Instances

IsOption REOptions RE CompOption ExecOption Source #
Methods makeREOptions :: REOptions -> REOptions_ RE CompOption ExecOption Source #
IsOption (Macros RE) RE CompOption ExecOption Source #
Methods makeREOptions :: Macros RE -> REOptions_ RE CompOption ExecOption Source #

data SimpleREOptions Source #

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 Source #
Methods minBound :: SimpleREOptions # maxBound :: SimpleREOptions #
Enum SimpleREOptions Source #
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 Source #
Methods (==) :: SimpleREOptions -> SimpleREOptions -> Bool # (/=) :: SimpleREOptions -> SimpleREOptions -> Bool #
Ord SimpleREOptions Source #
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 Source #
Methods showsPrec :: Int -> SimpleREOptions -> ShowS # show :: SimpleREOptions -> String # showList :: [SimpleREOptions] -> ShowS #
Lift SimpleREOptions Source #	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 Source #

extract the RE source string from the RE

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

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 Source #

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 Source #

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 Source #

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 Source #

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

module Text.RE.ZeInternals.TDFA