Safe Haskell	None
Language	Haskell2010

Text.RE.TDFA.ByteString.Lazy

Contents

Tutorial
The Matches and Match Operators
The SearchReplace Operators
The Classic rexex-base match Operators
Matches
Match
The RE Type and Functions
Orphan instances

Synopsis

Tutorial

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

The `Matches` and `Match` Operators

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

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

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

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

find first match in text

The `SearchReplace` Operators

(*=~/) :: ByteString -> SearchReplace RE ByteString -> ByteString 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}|])

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

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

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

ed :: QuasiQuoter Source #

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

edMS :: QuasiQuoter Source #

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

edMI :: QuasiQuoter Source #

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

edBS :: QuasiQuoter Source #

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

edBI :: QuasiQuoter Source #