| Copyright | (c) Chris Kuklewicz 2006 |
|---|---|
| License | BSD-3-Clause |
| Maintainer | hvr@gnu.org |
| Stability | experimental |
| Portability | non-portable (MPTC+FD) |
| Safe Haskell | Safe |
| Language | Haskell2010 |
Text.Regex.Base.RegexLike
Contents
Description
Classes and instances for Regex matching.
All the classes are declared here, and some common type aliases, and
the MatchResult data type.
The only instances here are for Extract String, Extract ByteString,
and Extract Text. There are no data values. The RegexContext
instances are in Text.Regex.Base.Context, except for ones which
run afoul of a repeated variable (RegexContext regex a a
Synopsis
- type MatchOffset = Int
- type MatchLength = Int
- type MatchArray = Array Int (MatchOffset, MatchLength)
- type MatchText source = Array Int (source, (MatchOffset, MatchLength))
- data MatchResult a = MR {}
- class RegexOptions regex compOpt execOpt | regex -> compOpt execOpt, compOpt -> regex execOpt, execOpt -> regex compOpt where
- blankCompOpt :: compOpt
- blankExecOpt :: execOpt
- defaultCompOpt :: compOpt
- defaultExecOpt :: execOpt
- setExecOpts :: execOpt -> regex -> regex
- getExecOpts :: regex -> execOpt
- class RegexOptions regex compOpt execOpt => RegexMaker regex compOpt execOpt source | regex -> compOpt execOpt, compOpt -> regex execOpt, execOpt -> regex compOpt where
- makeRegex :: source -> regex
- makeRegexOpts :: compOpt -> execOpt -> source -> regex
- makeRegexM :: MonadFail m => source -> m regex
- makeRegexOptsM :: MonadFail m => compOpt -> execOpt -> source -> m regex
- class Extract source => RegexLike regex source where
- matchOnce :: regex -> source -> Maybe MatchArray
- matchAll :: regex -> source -> [MatchArray]
- matchCount :: regex -> source -> Int
- matchTest :: regex -> source -> Bool
- matchAllText :: regex -> source -> [MatchText source]
- matchOnceText :: regex -> source -> Maybe (source, MatchText source, source)
- class RegexLike regex source => RegexContext regex source target where
- class Extract source where
- newtype AllSubmatches f b = AllSubmatches {
- getAllSubmatches :: f b
- newtype AllTextSubmatches f b = AllTextSubmatches {
- getAllTextSubmatches :: f b
- newtype AllMatches f b = AllMatches {
- getAllMatches :: f b
- newtype AllTextMatches f b = AllTextMatches {
- getAllTextMatches :: f b
Type aliases
type MatchOffset = Int #
0 based index from start of source, or (-1) for unused
type MatchLength = Int #
non-negative length of a match
type MatchArray = Array Int (MatchOffset, MatchLength) #
0 based array, with 0th index indicating the full match. If the full match location is not available, represent as (0,0).
type MatchText source = Array Int (source, (MatchOffset, MatchLength)) #
Data types
data MatchResult a #
This is the same as the type from JRegex.
Instances
| RegexLike a b => RegexContext a b (MatchResult b) # | |
Defined in Text.Regex.Base.Context | |
Classes
class RegexOptions regex compOpt execOpt | regex -> compOpt execOpt, compOpt -> regex execOpt, execOpt -> regex compOpt where #
Rather than carry them around spearately, the options for how to
execute a regex are kept as part of the regex. There are two types
of options. Those that can only be specified at compilation time
and never changed are compOpt. Those that can be changed later and
affect how matching is performed are execOpt. The actually types
for these depend on the backend.
Methods
blankCompOpt :: compOpt #
No options set at all in the backend.
blankExecOpt :: execOpt #
No options set at all in the backend.
defaultCompOpt :: compOpt #
Reasonable options (extended, caseSensitive, multiline regex).
defaultExecOpt :: execOpt #
Reasonable options (extended, caseSensitive, multiline regex).
setExecOpts :: execOpt -> regex -> regex #
Forget old flags and use new ones.
getExecOpts :: regex -> execOpt #
Retrieve the current flags.
class RegexOptions regex compOpt execOpt => RegexMaker regex compOpt execOpt source | regex -> compOpt execOpt, compOpt -> regex execOpt, execOpt -> regex compOpt where #
RegexMaker captures the creation of the compiled regular
expression from a source type and an option type. Methods makeRegexM and
makeRegexM report parse errors using MonadError, usually (Either
String regex).
The makeRegex function has a default implementation that depends
on makeRegexOpts and uses defaultCompOpt and defaultExecOpt.
Similarly for makeRegexM and makeRegexOptsM.
There are also default implementaions for makeRegexOpts and
makeRegexOptsM in terms of each other. So a minimal instance
definition needs to only define one of these, hopefully
makeRegexOptsM.
Minimal complete definition
Nothing
Methods
makeRegex :: source -> regex #
Use the defaultCompOpt and defaultExecOpt.
makeRegexOpts :: compOpt -> execOpt -> source -> regex #
Specify your own options.
makeRegexM :: MonadFail m => source -> m regex #
Use the defaultCompOpt and defaultExecOpt, reporting errors with fail.
makeRegexOptsM :: MonadFail m => compOpt -> execOpt -> source -> m regex #
Specify your own options, reporting errors with fail
class Extract source => RegexLike regex source where #
RegexLike is parametrized on a regular expression type and a source type to run the matching on.
There are default implementations: matchTest and matchOnceText use
matchOnce; matchCount and matchAllText use matchAll.
Conversely, matchOnce uses
matchOnceText and matchAll uses matchAllText. So a minimal complete
instance need to provide at least (matchOnce or matchOnceText) and
(matchAll or matchAllText). Additional definitions are often
provided where they will increase efficiency.
[ c | let notVowel = makeRegex "[^aeiou]" :: Regex, c <- ['a'..'z'], matchTest notVowel [c] ] "bcdfghjklmnpqrstvwxyz"
The strictness of these functions is instance dependent.
Minimal complete definition
Nothing
Methods
matchOnce :: regex -> source -> Maybe MatchArray #
This returns the first match in the source (it checks the whole source, not just at the start). This returns an array of (offset,length) index pairs for the match and captured substrings. The offset is 0-based. A (-1) for an offset means a failure to match. The lower bound of the array is 0, and the 0th element is the (offset,length) for the whole match.
matchAll :: regex -> source -> [MatchArray] #
matchAll returns a list of matches. The matches are in order
and do not overlap. If any match succeeds but has 0 length then
this will be the last match in the list.
matchCount :: regex -> source -> Int #
matchCount returns the number of non-overlapping matches
returned by matchAll.
matchTest :: regex -> source -> Bool #
matchTest returns True if there is a match somewhere in the
source (it checks the whole source not just at the start).
matchAllText :: regex -> source -> [MatchText source] #
This is matchAll with the actual subsections of the source
instead of just the (offset,length) information.
matchOnceText :: regex -> source -> Maybe (source, MatchText source, source) #
This can return a tuple of three items: the source before the match, an array of the match and captured substrings (with their indices), and the source after the match.
class RegexLike regex source => RegexContext regex source target where #
RegexContext is the polymorphic interface to do matching. Since
target is polymorphic you may need to supply the type explicitly
in contexts where it cannot be inferred.
The monadic matchM version uses fail to report when the regex
has no match in source. Two examples:
Here the contest Bool is inferred:
[ c | let notVowel = makeRegex "[^aeiou]" :: Regex, c <- ['a'..'z'], match notVowel [c] ] "bcdfghjklmnpqrstvwxyz"
Here the context [String] must be supplied:
let notVowel = (makeRegex "[^aeiou]" :: Regex )
in do { c <- ['a'..'z'] ; matchM notVowel [c] } :: [String]
["b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z"]Instances
Extract allows for indexing operations on String or ByteString.
Methods
before :: Int -> source -> source #
before is a renamed take.
after :: Int -> source -> source #
after is a renamed drop.
When there is no match, this can construct an empty data value.
extract :: (Int, Int) -> source -> source #
extract takes an offset and length, and has this default implementation:
extract (off, len) source = before len (after off source)
Instances
| Extract String # | |
| Extract ByteString # | |
Defined in Text.Regex.Base.RegexLike Methods before :: Int -> ByteString -> ByteString # after :: Int -> ByteString -> ByteString # empty :: ByteString # extract :: (Int, Int) -> ByteString -> ByteString # | |
| Extract ByteString # | |
Defined in Text.Regex.Base.RegexLike Methods before :: Int -> ByteString -> ByteString # after :: Int -> ByteString -> ByteString # empty :: ByteString # extract :: (Int, Int) -> ByteString -> ByteString # | |
| Extract Text # | Since: 0.94.0.0 |
| Extract Text # | Since: 0.94.0.0 |
| Extract (Seq a) # | |
newtype AllSubmatches f b #
Used in results of RegexContext instances.
Constructors
| AllSubmatches | |
Fields
| |
Instances
| RegexLike a b => RegexContext a b (AllSubmatches [] (MatchOffset, MatchLength)) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllSubmatches [] (MatchOffset, MatchLength) # matchM :: MonadFail m => a -> b -> m (AllSubmatches [] (MatchOffset, MatchLength)) # | |
newtype AllTextSubmatches f b #
Used in results of RegexContext instances.
Constructors
| AllTextSubmatches | |
Fields
| |
Instances
| RegexLike a b => RegexContext a b (AllTextSubmatches (Array Int) b) # | |
Defined in Text.Regex.Base.Context | |
| RegexLike a b => RegexContext a b (AllTextSubmatches [] b) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllTextSubmatches [] b # matchM :: MonadFail m => a -> b -> m (AllTextSubmatches [] b) # | |
| RegexLike a b => RegexContext a b (AllTextSubmatches [] (b, (MatchOffset, MatchLength))) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllTextSubmatches [] (b, (MatchOffset, MatchLength)) # matchM :: MonadFail m => a -> b -> m (AllTextSubmatches [] (b, (MatchOffset, MatchLength))) # | |
| RegexLike a b => RegexContext a b (AllTextSubmatches (Array Int) (b, (MatchOffset, MatchLength))) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllTextSubmatches (Array Int) (b, (MatchOffset, MatchLength)) # matchM :: MonadFail m => a -> b -> m (AllTextSubmatches (Array Int) (b, (MatchOffset, MatchLength))) # | |
newtype AllMatches f b #
Used in results of RegexContext instances.
Constructors
| AllMatches | |
Fields
| |
Instances
| RegexLike a b => RegexContext a b (AllMatches (Array Int) MatchArray) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllMatches (Array Int) MatchArray # matchM :: MonadFail m => a -> b -> m (AllMatches (Array Int) MatchArray) # | |
| RegexLike a b => RegexContext a b (AllMatches (Array Int) (MatchOffset, MatchLength)) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllMatches (Array Int) (MatchOffset, MatchLength) # matchM :: MonadFail m => a -> b -> m (AllMatches (Array Int) (MatchOffset, MatchLength)) # | |
| RegexLike a b => RegexContext a b (AllMatches [] (MatchOffset, MatchLength)) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllMatches [] (MatchOffset, MatchLength) # matchM :: MonadFail m => a -> b -> m (AllMatches [] (MatchOffset, MatchLength)) # | |
newtype AllTextMatches f b #
Used in results of RegexContext instances.
Constructors
| AllTextMatches | |
Fields
| |
Instances
| RegexLike a b => RegexContext a b (AllTextMatches (Array Int) (Array Int b)) # | |
| RegexLike a b => RegexContext a b (AllTextMatches [] (Array Int b)) # | |
Defined in Text.Regex.Base.Context | |
| RegexLike a b => RegexContext a b (AllTextMatches (Array Int) [b]) # | |
Defined in Text.Regex.Base.Context | |
| RegexLike a b => RegexContext a b (AllTextMatches (Array Int) b) # | |
Defined in Text.Regex.Base.Context | |
| RegexLike a b => RegexContext a b (AllTextMatches [] b) # | |
Defined in Text.Regex.Base.Context Methods match :: a -> b -> AllTextMatches [] b # matchM :: MonadFail m => a -> b -> m (AllTextMatches [] b) # | |
| RegexLike a b => RegexContext a b (AllTextMatches (Array Int) (MatchText b)) # | |
Defined in Text.Regex.Base.Context | |