Text.RE.ZeInternals.Replace

REContext and RELocation

data REContext

REContext specifies which contexts the substitutions should be applied

Constructors

TOP

substitutions should be applied to the top-level only, the text that matched the whole RE

SUB

substitutions should only be applied to the text captured by bracketed sub-REs

ALL

the substitution function should be applied to all captures, the top level and the sub-expression captures

Instances

Show REContext

Methods

showsPrec :: Int -> REContext -> ShowS

show :: REContext -> String

showList :: [REContext] -> ShowS

data RELocation

the RELocation information passed into the substitution function specifies which sub-expression is being substituted

Constructors

RELocation

Fields

• locationMatch :: Int

  the zero-based, i-th string to be matched, when matching all strings, zero when only the first string is being matched

• locationCapture :: CaptureOrdinal

  0, when matching the top-level string matched by the whole RE, 1 for the top-most, left-most redex captured by bracketed sub-REs, etc.

Instances

Show RELocation

Methods

showsPrec :: Int -> RELocation -> ShowS

show :: RELocation -> String

showList :: [RELocation] -> ShowS

isTopLocation :: RELocation -> Bool

True iff the location references a complete match (i.e., not a bracketed capture)

replaceAll

replaceAll :: Replace a => a -> Matches a -> a

replace all with a template, $0 for whole text, $1 for first capture, etc.

replaceAllCaptures :: Replace a => REContext -> (Match a -> RELocation -> Capture a -> Maybe a) -> Matches a -> a

substitutes using a function that takes the full Match context and returns the same replacement text as the _phi_phi context.

replaceAllCaptures_ :: Extract a => ReplaceMethods a -> REContext -> (Match a -> RELocation -> Capture a -> Maybe a) -> Matches a -> a

replaceAllCaptures_ is like like replaceAllCaptures but takes the Replace methods through the ReplaceMethods argument

replaceAllCapturesM :: (Extract a, Monad m) => ReplaceMethods a -> REContext -> (Match a -> RELocation -> Capture a -> m (Maybe a)) -> Matches a -> m a

replaceAllCapturesM is just a monadically generalised version of replaceAllCaptures_

replace

replace :: Replace a => a -> Match a -> a

replaceCaptures :: Replace a => REContext -> (Match a -> RELocation -> Capture a -> Maybe a) -> Match a -> a

substitutes using a function that takes the full Match context and returns the same replacement text as the _phi_phi context.

replaceCaptures_ :: Extract a => ReplaceMethods a -> REContext -> (Match a -> RELocation -> Capture a -> Maybe a) -> Match a -> a

replaceCaptures_ is like replaceCaptures but takes the Replace methods through the ReplaceMethods argument

replaceCapturesM :: (Monad m, Extract a) => ReplaceMethods a -> REContext -> (Match a -> RELocation -> Capture a -> m (Maybe a)) -> Match a -> m a

replaceCapturesM is just a monadically generalised version of replaceCaptures_

expandMacros

expandMacros :: (r -> String) -> Macros r -> String -> String

expand all of the @{..} macros in the RE in the argument String according to the Macros argument, preprocessing the RE String according to the Mode argument (used internally)

expandMacros' :: (MacroID -> Maybe String) -> String -> String

expand the @{..} macos in the argument string using the given function

templateCaptures

templateCaptures :: (Replace a, RegexContext Regex a (Matches a), RegexMaker Regex CompOption ExecOption String) => (a -> String) -> a -> [CaptureID]

list all of the CaptureID references in the replace template in the second argument

Replace and ReplaceMethods

class (Show a, Eq a, Ord a, Extract a, Monoid a) => Replace a where

Replace provides the missing needed to replace the matched text in a Replace a => Match a.

Minimal complete definition

lengthR, packR, unpackR, linesR, unlinesR, parseTemplateR

Methods

lengthR :: a -> Int

length function for a

packR :: String -> a

inject String into a

unpackR :: a -> String

project a onto a String

textifyR :: a -> Text

inject into Text

detextifyR :: Text -> a

project Text onto a

linesR :: a -> [a]

split into lines

unlinesR :: [a] -> a

concatenate a list of lines

appendNewlineR :: a -> a

append a newline

substR :: (a -> a) -> Capture a -> a

apply a substitution function to a Capture

parseTemplateR :: a -> Match a -> RELocation -> Capture a -> Maybe a

convert a template containing $0, $1, etc., in the first argument, into a phi replacement function for use with replaceAllCaptures and replaceCaptures

Instances

Replace ByteString

Methods

lengthR :: ByteString -> Int

packR :: String -> ByteString

unpackR :: ByteString -> String

textifyR :: ByteString -> Text

detextifyR :: Text -> ByteString

linesR :: ByteString -> [ByteString]

unlinesR :: [ByteString] -> ByteString

appendNewlineR :: ByteString -> ByteString

substR :: (ByteString -> ByteString) -> Capture ByteString -> ByteString

parseTemplateR :: ByteString -> Match ByteString -> RELocation -> Capture ByteString -> Maybe ByteString

Replace ByteString

Methods

lengthR :: ByteString -> Int

packR :: String -> ByteString

unpackR :: ByteString -> String

textifyR :: ByteString -> Text

detextifyR :: Text -> ByteString

linesR :: ByteString -> [ByteString]

unlinesR :: [ByteString] -> ByteString

appendNewlineR :: ByteString -> ByteString

substR :: (ByteString -> ByteString) -> Capture ByteString -> ByteString

parseTemplateR :: ByteString -> Match ByteString -> RELocation -> Capture ByteString -> Maybe ByteString

Replace Text

Methods

lengthR :: Text -> Int

packR :: String -> Text

unpackR :: Text -> String

textifyR :: Text -> Text

detextifyR :: Text -> Text

linesR :: Text -> [Text]

unlinesR :: [Text] -> Text

appendNewlineR :: Text -> Text

substR :: (Text -> Text) -> Capture Text -> Text

parseTemplateR :: Text -> Match Text -> RELocation -> Capture Text -> Maybe Text

Replace Text

Methods

lengthR :: Text -> Int

packR :: String -> Text

unpackR :: Text -> String

textifyR :: Text -> Text

detextifyR :: Text -> Text

linesR :: Text -> [Text]

unlinesR :: [Text] -> Text

appendNewlineR :: Text -> Text

substR :: (Text -> Text) -> Capture Text -> Text

parseTemplateR :: Text -> Match Text -> RELocation -> Capture Text -> Maybe Text

Replace [Char]

Methods

lengthR :: [Char] -> Int

packR :: String -> [Char]

unpackR :: [Char] -> String

textifyR :: [Char] -> Text

detextifyR :: Text -> [Char]

linesR :: [Char] -> [[Char]]

unlinesR :: [[Char]] -> [Char]

appendNewlineR :: [Char] -> [Char]

substR :: ([Char] -> [Char]) -> Capture [Char] -> [Char]

parseTemplateR :: [Char] -> Match [Char] -> RELocation -> Capture [Char] -> Maybe [Char]

Replace (Seq Char)

Methods

lengthR :: Seq Char -> Int

packR :: String -> Seq Char

unpackR :: Seq Char -> String

textifyR :: Seq Char -> Text

detextifyR :: Text -> Seq Char

linesR :: Seq Char -> [Seq Char]

unlinesR :: [Seq Char] -> Seq Char

appendNewlineR :: Seq Char -> Seq Char

substR :: (Seq Char -> Seq Char) -> Capture (Seq Char) -> Seq Char

parseTemplateR :: Seq Char -> Match (Seq Char) -> RELocation -> Capture (Seq Char) -> Maybe (Seq Char)

data ReplaceMethods a

a selction of the Replace methods can be encapsulated with ReplaceMethods for the higher-order replacement functions

Constructors

ReplaceMethods

Fields

• methodLength :: a -> Int
• methodSubst :: (a -> a) -> Capture a -> a

replaceMethods :: Replace a => ReplaceMethods a

replaceMethods encapsulates ReplaceMethods a from a Replace a context