Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
A Haskell quasi-quoter for typeful results of regex captures.
Haskell
branch: master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
Text/Regex/PCRE
.gitignore Add "TAGS" to .gitignore
.travis.yml Add a .travis.yml
Bench.hs Use some better hackage URLs
CHANGES.md
Demo.hs
LICENSE Initial commit. Pattern quasi-quoting broken (due to haskell-src-exts…
README.md Fix readme formatting, rename test to demo
Setup.hs Initial commit. Pattern quasi-quoting broken (due to haskell-src-exts…
rex.cabal Version 0.5.1

README.md

http://hackage.haskell.org/package/rex

Provides a quasi-quoter for regular expressions which yields a tuple, of appropriate arity and types, representing the results of the captures. Allows the user to specify parsers for captures as inline Haskell. Can also be used to provide typeful pattern matching in function definitions and case patterns.

To build / install:

./Setup.hs configure --user
./Setup.hs build
./Setup.hs install

See the haddock or Text/Regex/PCRE/Rex.hs for documentation.

Some examples (verbatim from Test.hs):

math x = mathl x 0

mathl [] x = x
mathl [rex|^  \s*(?{ read -> y }\d+)\s*(?{ s }.*)$|] x = mathl s y
mathl [rex|^\+\s*(?{ read -> y }\d+)\s*(?{ s }.*)$|] x = mathl s $ x + y
mathl [rex|^ -\s*(?{ read -> y }\d+)\s*(?{ s }.*)$|] x = mathl s $ x - y
mathl [rex|^\*\s*(?{ read -> y }\d+)\s*(?{ s }.*)$|] x = mathl s $ x * y
mathl [rex|^ /\s*(?{ read -> y }\d+)\s*(?{ s }.*)$|] x = mathl s $ x / y
mathl str x = error str

-- math "1 + 3" == 4.0
-- math "3 * 2 + 100" == 106.0
-- math "20 / 3 + 100 * 2" == 213.33333333333334
peano :: String -> Maybe Int
peano = [rex|^(?{ length . filter (=='S') } \s* (?:S\s+)*Z)\s*$|]

--  peano "S Z" == Just 1
--  peano "S S S S Z" == Just 4
--  peano "S   S   Z" == Just 2
parsePair :: String -> Maybe (String, String)
parsePair = [rex|^<\s* (?{ }[^\s,>]+) \s*,\s* (?{ }[^\s,>]+) \s*>$|]

--  parsePair "<-1, 3>" == Just ("-1","3")
--  parsePair "<-4,3b0>" == Just ("-4","3b0")
--  parsePair "< a,  -30 >" == Just ("a","-30")
--  parsePair "< a,  other>" == Just ("a","other")
-- From http://www.regular-expressions.info/dates.html
parseDate :: String -> Maybe (Int, Int, Int)
parseDate [rex|^(?{ read -> y }(?:19|20)\d\d)[- /.]
                (?{ read -> m }0[1-9]|1[012])[- /.]
                (?{ read -> d }0[1-9]|[12][0-9]|3[01])$|]
  |  (d > 30 && (m `elem` [4, 6, 9, 11]))
  || (m == 2 &&
       (d ==29 && not (mod y 4 == 0 && (mod y 100 /= 0 || mod y 400 == 0)))
    || (d > 29)) = Nothing
  | otherwise = Just (y, m, d)
parseDate _ = Nothing

--  parseDate "1993.8.10" == Nothing
--  parseDate "1993.08.10" == Just (1993,8,10)
--  parseDate "2003.02.28" == Just (2003,2,28)
--  parseDate "2003.02.27" == Just (2003,2,27)
onNull a f [] = a
onNull _ f xs = f xs

nonNull = onNull Nothing

disjunct [rex| ^(?:(?{nonNull $ Just . head -> a} .)
             | (?{nonNull $ Just . head -> b} ..)
             | (?{nonNull $ Just . last -> c} ...))$|] =
  head $ catMaybes [a, b, c]

--  disjunct "a" == 'a'
--  disjunct "ab" == 'a'
--  disjunct "abc" == 'c'
Something went wrong with that request. Please try again.