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 matches in text; e.g., to count the number of naturals in s:

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

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

find first match in text

The SearchReplace Operators

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

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}|])

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

search and replace the first occurrence only

The Classic rexex-base match Operators

(=~) :: (Typeable a, RegexContext Regex ByteString a, RegexMaker Regex CompOption ExecOption String) => ByteString -> RE -> a

the regex-base polymorphic match operator

(=~~) :: (Monad m, Functor m, Typeable a, RegexContext Regex ByteString a, RegexMaker Regex CompOption ExecOption String) => ByteString -> 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 REOptions_ actually as apropriate the chosen back end

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.TDFA.RE

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

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