Text.Regex.Posix.Sequence

regex-posix-0.96.0.1: POSIX Backend for "Text.Regex" (regex-base)

Copyright | (c) Chris Kuklewicz 2006
License | BSD-3-Clause
Maintainer | hvr@gnu.org, Andreas Abel
Stability | stable
Portability | non-portable (regex-base needs MPTC+FD)
Safe Haskell | None
Language | Haskell2010

Text.Regex.Posix.Sequence

Contents

- Types
- Miscellaneous
- Medium level API functions
- Compilation options
- Orphan instances

Description

This provides `String` instances for `RegexMaker` and `RegexLike` based on Text.Regex.Posix.Wrap, and a (`RegexContext` `Regex` `String` `String`) instance.

To use these instance, you would normally import Text.Regex.Posix. You only need to import this module to use the medium level API of the compile, regexec, and execute functions. All of these report error by returning Left values instead of undefined or error or fail.

Synopsis

- data Regex
- type MatchOffset = Int
- type MatchLength = Int
- data ReturnCode
- type WrapError = (ReturnCode, String)
- unusedOffset :: Int
- compile :: CompOption -> ExecOption -> Seq Char -> IO (Either WrapError Regex)
- regexec :: Regex -> Seq Char -> IO (Either WrapError (Maybe (Seq Char, Seq Char, Seq Char, [Seq Char])))
- execute :: Regex -> Seq Char -> IO (Either WrapError (Maybe (Array Int (MatchOffset, MatchLength))))
- newtype CompOption = CompOption CInt
- compBlank :: CompOption
- compExtended :: CompOption
- compIgnoreCase :: CompOption
- compNoSub :: CompOption
- compNewline :: CompOption
- newtype ExecOption = ExecOption CInt
- execBlank :: ExecOption
- execNotBOL :: ExecOption
- execNotEOL :: ExecOption

## Types

data Regex #

A compiled regular expression.

#### Instances

Instances details

RegexLike Regex ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString Methods matchOnce :: Regex -> ByteString -> Maybe MatchArray # matchAll :: Regex -> ByteString -> [MatchArray] # matchCount :: Regex -> ByteString -> Int # matchTest :: Regex -> ByteString -> Bool # matchAllText :: Regex -> ByteString -> [MatchText ByteString] # matchOnceText :: Regex -> ByteString -> Maybe (ByteString, MatchText ByteString, ByteString) #
RegexLike Regex ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString.Lazy Methods matchOnce :: Regex -> ByteString -> Maybe MatchArray # matchAll :: Regex -> ByteString -> [MatchArray] # matchCount :: Regex -> ByteString -> Int # matchTest :: Regex -> ByteString -> Bool # matchAllText :: Regex -> ByteString -> [MatchText ByteString] # matchOnceText :: Regex -> ByteString -> Maybe (ByteString, MatchText ByteString, ByteString) #
RegexLike Regex String # |
Instance details Defined in Text.Regex.Posix.String Methods matchOnce :: Regex -> String -> Maybe MatchArray # matchAll :: Regex -> String -> [MatchArray] # matchCount :: Regex -> String -> Int # matchTest :: Regex -> String -> Bool # matchAllText :: Regex -> String -> [MatchText String] # matchOnceText :: Regex -> String -> Maybe (String, MatchText String, String) #
RegexContext Regex ByteString ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString Methods match :: Regex -> ByteString -> ByteString # matchM :: MonadFail m => Regex -> ByteString -> m ByteString #
RegexContext Regex ByteString ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString.Lazy Methods match :: Regex -> ByteString -> ByteString # matchM :: MonadFail m => Regex -> ByteString -> m ByteString #
RegexContext Regex String String # |
Instance details Defined in Text.Regex.Posix.String Methods match :: Regex -> String -> String # matchM :: MonadFail m => Regex -> String -> m String #
RegexOptions Regex CompOption ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods blankCompOpt :: CompOption # blankExecOpt :: ExecOption # defaultCompOpt :: CompOption # defaultExecOpt :: ExecOption # setExecOpts :: ExecOption -> Regex -> Regex # getExecOpts :: Regex -> ExecOption #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString.Lazy Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption String # |
Instance details Defined in Text.Regex.Posix.String Methods makeRegex :: String -> Regex # makeRegexOpts :: CompOption -> ExecOption -> String -> Regex # makeRegexM :: MonadFail m => String -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> String -> m Regex #
RegexMaker Regex CompOption ExecOption (Seq Char) # |
Instance details Defined in Text.Regex.Posix.Sequence Methods makeRegex :: Seq Char -> Regex # makeRegexOpts :: CompOption -> ExecOption -> Seq Char -> Regex # makeRegexM :: MonadFail m => Seq Char -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> Seq Char -> m Regex #
RegexLike Regex (Seq Char) # |
Instance details Defined in Text.Regex.Posix.Sequence Methods matchOnce :: Regex -> Seq Char -> Maybe MatchArray # matchAll :: Regex -> Seq Char -> [MatchArray] # matchCount :: Regex -> Seq Char -> Int # matchTest :: Regex -> Seq Char -> Bool # matchAllText :: Regex -> Seq Char -> [MatchText (Seq Char)] # matchOnceText :: Regex -> Seq Char -> Maybe (Seq Char, MatchText (Seq Char), Seq Char) #
RegexContext Regex (Seq Char) (Seq Char) # |
Instance details Defined in Text.Regex.Posix.Sequence Methods match :: Regex -> Seq Char -> Seq Char # matchM :: MonadFail m => Regex -> Seq Char -> m (Seq Char) #

type MatchOffset = Int #

0 based index from start of source, or (-1) for unused

type MatchLength = Int #

non-negative length of a match

data ReturnCode #

ReturnCode is an enumerated `CInt`, corresponding to the error codes from `man 3 regex`:

- `retBadbr` (`REG_BADBR`) invalid repetition count(s) in `{ }`
- `retBadpat` (`REG_BADPAT`) invalid regular expression
- `retBadrpt` (`REG_BADRPT`) `?`, `*`, or `+` operand invalid
- `retEcollate` (`REG_ECOLLATE`) invalid collating element
- `retEctype` (`REG_ECTYPE`) invalid character class
- `retEescape` (`REG_EESCAPE`) `\` applied to unescapable character
- `retEsubreg` (`REG_ESUBREG`) invalid backreference number
- `retEbrack` (`REG_EBRACK`) brackets `[ ]` not balanced
- `retEparen` (`REG_EPAREN`) parentheses `( )` not balanced
- `retEbrace` (`REG_EBRACE`) braces `{ }` not balanced
- `retErange` (`REG_ERANGE`) invalid character range in `[ ]`
- `retEspace` (`REG_ESPACE`) ran out of memory
- `retNoMatch` (`REG_NOMATCH`) The regexec() function failed to match

#### Instances

Instances details

Show ReturnCode # |
Instance details Defined in Text.Regex.Posix.Wrap Methods showsPrec :: Int -> ReturnCode -> ShowS # show :: ReturnCode -> String # showList :: [ReturnCode] -> ShowS #
Eq ReturnCode # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (==) :: ReturnCode -> ReturnCode -> Bool # (/=) :: ReturnCode -> ReturnCode -> Bool #

type WrapError = (ReturnCode, String) #

The return code will be `retOk` when it is the Haskell wrapper and not the underlying library generating the error message.

## Miscellaneous

unusedOffset :: Int #

## Medium level API functions

compile #

Arguments

:: CompOption | Flags (summed together)
-> ExecOption | Flags (summed together)
-> Seq Char | The regular expression to compile (ASCII only, no null bytes)
-> IO (Either WrapError Regex) | Returns: the compiled regular expression

regexec #

Arguments

:: Regex | Compiled regular expression
-> Seq Char | Text to match against
-> IO (Either WrapError (Maybe (Seq Char, Seq Char, Seq Char, [Seq Char]))) | Returns: `Nothing` if the regex did not match the string, or:
      Just (everything before match,
            matched portion,
            everything after match,
            subexpression matches)

Matches a regular expression against a string

execute #

Arguments

:: Regex | Compiled regular expression
-> Seq Char | Text to match against
-> IO (Either WrapError (Maybe (Array Int (MatchOffset, MatchLength)))) | Returns: `Nothing` if the regex did not match the string, or:
      Just (array of offset length pairs)

Matches a regular expression against a string

## Compilation options

newtype CompOption #

A bitmapped `CInt` containing options for compilation of regular expressions. Option values (and their man 3 regcomp names) are

- `compBlank` which is a completely zero value for all the flags. This is also the `blankCompOpt` value.
- `compExtended` (REG_EXTENDED) which can be set to use extended instead of basic regular expressions. This is set in the `defaultCompOpt` value.
- `compNewline` (REG_NEWLINE) turns on newline sensitivity: The dot (.) and inverted set `[^ ]` never match newline, and ^ and $ anchors do match after and before newlines. This is set in the `defaultCompOpt` value.
- `compIgnoreCase` (REG_ICASE) which can be set to match ignoring upper and lower distinctions.
- `compNoSub` (REG_NOSUB) which turns off all information from matching except whether a match exists.

Constructors

CompOption CInt |

#### Instances

Instances details

Bits CompOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (.&.) :: CompOption -> CompOption -> CompOption # (.|.) :: CompOption -> CompOption -> CompOption # xor :: CompOption -> CompOption -> CompOption # complement :: CompOption -> CompOption # shift :: CompOption -> Int -> CompOption # rotate :: CompOption -> Int -> CompOption # zeroBits :: CompOption # bit :: Int -> CompOption # setBit :: CompOption -> Int -> CompOption # clearBit :: CompOption -> Int -> CompOption # complementBit :: CompOption -> Int -> CompOption # testBit :: CompOption -> Int -> Bool # bitSizeMaybe :: CompOption -> Maybe Int # bitSize :: CompOption -> Int # isSigned :: CompOption -> Bool # shiftL :: CompOption -> Int -> CompOption # unsafeShiftL :: CompOption -> Int -> CompOption # shiftR :: CompOption -> Int -> CompOption # unsafeShiftR :: CompOption -> Int -> CompOption # rotateL :: CompOption -> Int -> CompOption # rotateR :: CompOption -> Int -> CompOption # popCount :: CompOption -> Int #
Num CompOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (+) :: CompOption -> CompOption -> CompOption # (-) :: CompOption -> CompOption -> CompOption # (*) :: CompOption -> CompOption -> CompOption # negate :: CompOption -> CompOption # abs :: CompOption -> CompOption # signum :: CompOption -> CompOption # fromInteger :: Integer -> CompOption #
Show CompOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods showsPrec :: Int -> CompOption -> ShowS # show :: CompOption -> String # showList :: [CompOption] -> ShowS #
Eq CompOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (==) :: CompOption -> CompOption -> Bool # (/=) :: CompOption -> CompOption -> Bool #
RegexOptions Regex CompOption ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods blankCompOpt :: CompOption # blankExecOpt :: ExecOption # defaultCompOpt :: CompOption # defaultExecOpt :: ExecOption # setExecOpts :: ExecOption -> Regex -> Regex # getExecOpts :: Regex -> ExecOption #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString.Lazy Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption String # |
Instance details Defined in Text.Regex.Posix.String Methods makeRegex :: String -> Regex # makeRegexOpts :: CompOption -> ExecOption -> String -> Regex # makeRegexM :: MonadFail m => String -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> String -> m Regex #
RegexMaker Regex CompOption ExecOption (Seq Char) # |
Instance details Defined in Text.Regex.Posix.Sequence Methods makeRegex :: Seq Char -> Regex # makeRegexOpts :: CompOption -> ExecOption -> Seq Char -> Regex # makeRegexM :: MonadFail m => Seq Char -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> Seq Char -> m Regex #

compBlank :: CompOption #

A completely zero value for all the flags. This is also the `blankCompOpt` value.

compExtended :: CompOption #

compIgnoreCase :: CompOption #

compNoSub :: CompOption #

compNewline :: CompOption #

newtype ExecOption #

A bitmapped `CInt` containing options for execution of compiled regular expressions. Option values (and their man 3 regexec names) are

- `execBlank` which is a complete zero value for all the flags. This is the `blankExecOpt` value.
- `execNotBOL` (REG_NOTBOL) can be set to prevent ^ from matching at the start of the input.
- `execNotEOL` (REG_NOTEOL) can be set to prevent $ from matching at the end of the input (before the terminating NUL).

Constructors

ExecOption CInt |

#### Instances

Instances details

Bits ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (.&.) :: ExecOption -> ExecOption -> ExecOption # (.|.) :: ExecOption -> ExecOption -> ExecOption # xor :: ExecOption -> ExecOption -> ExecOption # complement :: ExecOption -> ExecOption # shift :: ExecOption -> Int -> ExecOption # rotate :: ExecOption -> Int -> ExecOption # zeroBits :: ExecOption # bit :: Int -> ExecOption # setBit :: ExecOption -> Int -> ExecOption # clearBit :: ExecOption -> Int -> ExecOption # complementBit :: ExecOption -> Int -> ExecOption # testBit :: ExecOption -> Int -> Bool # bitSizeMaybe :: ExecOption -> Maybe Int # bitSize :: ExecOption -> Int # isSigned :: ExecOption -> Bool # shiftL :: ExecOption -> Int -> ExecOption # unsafeShiftL :: ExecOption -> Int -> ExecOption # shiftR :: ExecOption -> Int -> ExecOption # unsafeShiftR :: ExecOption -> Int -> ExecOption # rotateL :: ExecOption -> Int -> ExecOption # rotateR :: ExecOption -> Int -> ExecOption # popCount :: ExecOption -> Int #
Num ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (+) :: ExecOption -> ExecOption -> ExecOption # (-) :: ExecOption -> ExecOption -> ExecOption # (*) :: ExecOption -> ExecOption -> ExecOption # negate :: ExecOption -> ExecOption # abs :: ExecOption -> ExecOption # signum :: ExecOption -> ExecOption # fromInteger :: Integer -> ExecOption #
Show ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods showsPrec :: Int -> ExecOption -> ShowS # show :: ExecOption -> String # showList :: [ExecOption] -> ShowS #
Eq ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods (==) :: ExecOption -> ExecOption -> Bool # (/=) :: ExecOption -> ExecOption -> Bool #
RegexOptions Regex CompOption ExecOption # |
Instance details Defined in Text.Regex.Posix.Wrap Methods blankCompOpt :: CompOption # blankExecOpt :: ExecOption # defaultCompOpt :: CompOption # defaultExecOpt :: ExecOption # setExecOpts :: ExecOption -> Regex -> Regex # getExecOpts :: Regex -> ExecOption #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption ByteString # |
Instance details Defined in Text.Regex.Posix.ByteString.Lazy Methods makeRegex :: ByteString -> Regex # makeRegexOpts :: CompOption -> ExecOption -> ByteString -> Regex # makeRegexM :: MonadFail m => ByteString -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> ByteString -> m Regex #
RegexMaker Regex CompOption ExecOption String # |
Instance details Defined in Text.Regex.Posix.String Methods makeRegex :: String -> Regex # makeRegexOpts :: CompOption -> ExecOption -> String -> Regex # makeRegexM :: MonadFail m => String -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> String -> m Regex #
RegexMaker Regex CompOption ExecOption (Seq Char) # |
Instance details Defined in Text.Regex.Posix.Sequence Methods makeRegex :: Seq Char -> Regex # makeRegexOpts :: CompOption -> ExecOption -> Seq Char -> Regex # makeRegexM :: MonadFail m => Seq Char -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> Seq Char -> m Regex #

execBlank :: ExecOption #

A completely zero value for all the flags. This is also the `blankExecOpt` value.

execNotBOL :: ExecOption #

execNotEOL :: ExecOption #

# Orphan instances

RegexMaker Regex CompOption ExecOption (Seq Char) # |
Instance details Methods makeRegex :: Seq Char -> Regex # makeRegexOpts :: CompOption -> ExecOption -> Seq Char -> Regex # makeRegexM :: MonadFail m => Seq Char -> m Regex # makeRegexOptsM :: MonadFail m => CompOption -> ExecOption -> Seq Char -> m Regex #
RegexLike Regex (Seq Char) # |
Instance details Methods matchOnce :: Regex -> Seq Char -> Maybe MatchArray # matchAll :: Regex -> Seq Char -> [MatchArray] # matchCount :: Regex -> Seq Char -> Int # matchTest :: Regex -> Seq Char -> Bool # matchAllText :: Regex -> Seq Char -> [MatchText (Seq Char)] # matchOnceText :: Regex -> Seq Char -> Maybe (Seq Char, MatchText (Seq Char), Seq Char) #
RegexContext Regex (Seq Char) (Seq Char) # |
Instance details Methods match :: Regex -> Seq Char -> Seq Char # matchM :: MonadFail m => Regex -> Seq Char -> m (Seq Char) #