Skylighting.Regex

Documentation

data Regex

Constructors

MatchAnyChar

MatchDynamic !Int

MatchChar (Char -> Bool)

MatchSome !Regex

MatchAlt !Regex !Regex

MatchConcat !Regex !Regex

MatchCapture !Int !Regex

MatchCaptured !Int

AssertWordBoundary

AssertBeginning

AssertEnd

AssertPositive !Direction !Regex

AssertNegative !Direction !Regex

Possessive !Regex

Lazy !Regex

Recurse

MatchNull

Instances

Show Regex

Defined in Regex.KDE.Regex

Methods

showsPrec :: Int -> Regex -> ShowS

show :: Regex -> String

showList :: [Regex] -> ShowS

Semigroup Regex

Defined in Regex.KDE.Regex

Methods

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

sconcat :: NonEmpty Regex -> Regex

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

Monoid Regex

Defined in Regex.KDE.Regex

Methods

mempty :: Regex

mappend :: Regex -> Regex -> Regex

mconcat :: [Regex] -> Regex

data RE

A representation of a regular expression.

Constructors

RE

Fields

• reString :: ByteString
• reCaseSensitive :: Bool

Instances

Eq RE

Defined in Skylighting.Regex

Methods

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

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

Data RE

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

Ord RE

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

Read RE

Defined in Skylighting.Regex

Methods

readsPrec :: Int -> ReadS RE

readList :: ReadS [RE]

readPrec :: ReadPrec RE

readListPrec :: ReadPrec [RE]

Show RE

Defined in Skylighting.Regex

Methods

showsPrec :: Int -> RE -> ShowS

show :: RE -> String

showList :: [RE] -> ShowS

Generic RE

Defined in Skylighting.Regex

Associated Types

type Rep RE :: Type -> Type

Methods

from :: RE -> Rep RE x

to :: Rep RE x -> RE

ToJSON RE

Defined in Skylighting.Regex

Methods

toJSON :: RE -> Value

toEncoding :: RE -> Encoding

toJSONList :: [RE] -> Value

toEncodingList :: [RE] -> Encoding

FromJSON RE

Defined in Skylighting.Regex

Methods

parseJSON :: Value -> Parser RE

parseJSONList :: Value -> Parser [RE]

Binary RE

Defined in Skylighting.Regex

Methods

put :: RE -> Put

get :: Get RE

putList :: [RE] -> Put

type Rep RE

Defined in Skylighting.Regex

type Rep RE = D1 ('MetaData "RE" "Skylighting.Regex" "skylighting-core-0.10.5.1-AFpz2V9yu8Z6VUCstianHd" 'False) (C1 ('MetaCons "RE" 'PrefixI 'True) (S1 ('MetaSel ('Just "reString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString) :*: S1 ('MetaSel ('Just "reCaseSensitive") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))

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

Compile a UTF-8 encoded ByteString as a Regex. If the first parameter is True, then the Regex will be case sensitive.

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

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). 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 smaller matches. Hence certain regexes may incorrectly fail to match: e.g. a*a{3000}$ on a string of 3000 as.

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

isWordChar :: Char -> Bool