skylighting-core
Safe HaskellNone
LanguageHaskell2010

Skylighting.Regex

Synopsis

Documentation

data Regex Source #

Instances

Instances details
Monoid Regex Source # 
Instance details

Defined in Regex.KDE.Regex

Semigroup Regex Source # 
Instance details

Defined in Regex.KDE.Regex

Methods

(<>) :: Regex -> Regex -> Regex

sconcat :: NonEmpty Regex -> Regex

stimes :: Integral b => b -> Regex -> Regex

Show Regex Source # 
Instance details

Defined in Regex.KDE.Regex

Methods

showsPrec :: Int -> Regex -> ShowS

show :: Regex -> String

showList :: [Regex] -> ShowS

data RE Source #

A representation of a regular expression.

Instances

Instances details
FromJSON RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

parseJSON :: Value -> Parser RE

parseJSONList :: Value -> Parser [RE]

omittedField :: Maybe RE

ToJSON RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

toJSON :: RE -> Value

toEncoding :: RE -> Encoding

toJSONList :: [RE] -> Value

toEncodingList :: [RE] -> Encoding

omitField :: RE -> Bool

Binary RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

put :: RE -> Put

get :: Get RE

putList :: [RE] -> Put

Data RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RE -> c RE

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RE

toConstr :: RE -> Constr

dataTypeOf :: RE -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RE)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RE)

gmapT :: (forall b. Data b => b -> b) -> RE -> RE

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RE -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RE -> r

gmapQ :: (forall d. Data d => d -> u) -> RE -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RE -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RE -> m RE

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RE -> m RE

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RE -> m RE

Read RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

readsPrec :: Int -> ReadS RE

readList :: ReadS [RE]

readPrec :: ReadPrec RE

readListPrec :: ReadPrec [RE]

Show RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

showsPrec :: Int -> RE -> ShowS

show :: RE -> String

showList :: [RE] -> ShowS

Eq RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

(==) :: RE -> RE -> Bool

(/=) :: RE -> RE -> Bool

Ord RE Source # 
Instance details

Defined in Skylighting.Regex

Methods

compare :: RE -> RE -> Ordering

(<) :: RE -> RE -> Bool

(<=) :: RE -> RE -> Bool

(>) :: RE -> RE -> Bool

(>=) :: RE -> RE -> Bool

max :: RE -> RE -> RE

min :: RE -> RE -> RE

pattern RE :: ByteString -> Bool -> Bool -> RE Source #

reMinimal :: RE -> Bool Source #

reString :: RE -> ByteString Source #

compileRE :: RE -> Either String (Regex, IntMap Regex) Source #

The compiled regex and its capturing groups (cached in the RE by the smart constructor).

compileRegex :: Bool -> Bool -> ByteString -> Either String Regex Source #

Compile a UTF-8 encoded ByteString as a Regex. If the first parameter is True, then the Regex will be case sensitive. If the second parameter is True, quantifiers are minimal (lazy) rather than greedy by default, and the ? modifier makes them greedy instead of lazy -- this corresponds to PCRE's UNGREEDY option (QRegularExpression's InvertedGreedinessOption, set by minimal="1" in KDE syntax definitions).

matchRegex :: Regex -> ByteString -> Maybe (ByteString, IntMap (Int, Int)) Source #

Match a Regex against a (presumed UTF-8 encoded) ByteString, returning the matched text and a map of (offset, size) pairs for captures. Note that all matches are from the beginning of the string (a ^ anchor is implicit). As in PCRE, the match returned is the first one that a backtracking matcher would find (leftmost alternatives are preferred), which is not necessarily the longest. Note also that to avoid pathological performance in certain cases, the matcher is limited to considering 2000 possible matches at a time; when that threshold is reached, it discards lower-priority matches. Hence certain regexes may incorrectly fail to match: e.g. a*a{3000}$ on a string of 3000 as.

matchRegexWithGroups :: IntMap Regex -> Regex -> ByteString -> Maybe (ByteString, IntMap (Int, Int)) Source #

Like matchRegex, but takes the map of capturing groups (as computed by extractCapturingGroups) as an argument, so that it can be computed once per regex instead of once per match. (The map is only consulted for regexes containing subroutine calls like (?1) or (?R).)

testRegex :: Bool -> String -> String -> Maybe (String, [(Int, String)]) Source #

isWordChar :: Char -> Bool Source #