https://github.com/unkindpartition/regex-applicative

Regex-based parsing with an applicative interface
https://github.com/unkindpartition/regex-applicative

parsing regex

Last synced: about 2 months ago
JSON representation

Regex-based parsing with an applicative interface

• Host: GitHub
• URL: https://github.com/unkindpartition/regex-applicative
• Owner: UnkindPartition
• License: mit
• Created: 2011-06-28T20:37:43.000Z (over 13 years ago)
• Default Branch: master
• Last Pushed: 2021-12-19T16:53:34.000Z (about 3 years ago)
• Last Synced: 2024-10-29T21:59:26.878Z (about 2 months ago)
• Topics: parsing, regex
• Language: Haskell
• Homepage:
• Size: 157 KB
• Stars: 130
• Watchers: 10
• Forks: 12
• Open Issues: 13
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGES.md
  • Contributing: CONTRIBUTING.md
  • License: LICENSE

Awesome Lists containing this project

README

        
regex-applicative

=================

*regex-applicative* is a parsing combinator library for Haskell based on regular

expressions.

Example

-------

``` haskell

import Text.Regex.Applicative

data Protocol = HTTP | FTP deriving Show

protocol :: RE Char Protocol

protocol = HTTP <$ string "http" <|> FTP <$ string "ftp"

type Host = String

type Location = String

data URL = URL Protocol Host Location deriving Show

host :: RE Char Host

host = many $ psym $ (/= '/')

url :: RE Char URL

url = URL <$> protocol <* string "://" <*> host <* sym '/' <*> many anySym

main = print $ "http://stackoverflow.com/questions" =~ url

```

Documentation

-------------

See the [API reference][haddock].

Performance

-----------

For common tasks, this package is several times slower than monadic

parser combinator libraries like parsec. However, this library has a roughly

linear complexity, whereas monadic parser combinators have exponential

worst-time complexity (see [here](https://swtch.com/~rsc/regexp/regexp1.html)).

Some tips to make your regex run faster:

1. If you don't care about the result of the whole regex or its part, only

   whether it matches or not, mark it with `void` or `<$`. Recognition is faster

   than parsing.

1. If you apply the same regex to multiple strings, partially apply it like so:

   ```

   let matcher = match my_regex

   in  map matcher my_strings

   ```

   This way the compiled regex is stored in the `matcher` value and shared among

   the strings.

GHC support

-----------

Only GHC versions >= 8.0 are supported, although older versions may work too.

[haddock]: http://hackage.haskell.org/packages/archive/regex-applicative/latest/doc/html/Text-Regex-Applicative.html