Safe Haskell  None 

Language  Haskell98 
Linear time composable parser for PEG grammars.
frisby is a parser library that can parse arbitrary PEG grammars in linear time. Unlike other parsers of PEG grammars, frisby need not be supplied with all possible rules up front, allowing composition of smaller parsers.
PEG parsers are never ambiguous and allow infinite lookahead with no backtracking penalty. Since PEG parsers can look ahead arbitrarily, they can easily express rules such as the maximal munch rule used in lexers, meaning no separate lexer is needed.
In addition to many standard combinators, frisby provides routines to translate standard regex syntax into frisby parsers.
PEG based parsers have a number of advantages over other parsing strategies:
 PEG parsers are never ambiguous
 PEG is a generalization of regexes, they can be though of as extended regexes with recursion, predicates, and ordered choice
 you never need a separate lexing pass with PEG parsers, since you have arbitrary lookahead there is no need to break the stream into tokens to allow the limited LALR or LL lookahead to work.
 things like the maximal munch and minimal munch rules are trivial to specify with PEGs, yet tricky with other parsers
 since you have ordered choice, things like the if then else ambiguity are nonexistent.
 parsers are very very fast, guaranteeing time linear in the size of the input, at the cost of greater memory consumption
 the ability to make local choices about whether to accept something lets you write parsers that deal gracefully with errors very easy to write, no more uninformative "parse error" messages
 PEG parsers can be fully lazy, only as much of the input is read as is needed to satisfy the demand on the output, and once the output has been processed, the memory is immediately reclaimed since a PEG parser never
backtracks
 PEG parsers can deal with infinite input, acting in a streaming manner
 PEG parsers support predicates, letting you decide what rules to follow based on whether other rules apply, so you can have rules that match only if another rule does not match, or a rule that matches only if two other rules both match the same input.
Traditionally, PEG parsers have suffered from two major flaws:
 A global table of all productions must be generated or written by hand, disallowing composable parsers implemented as libraries and in general requiring the use of a parser generator tool like
pappy
 Although memory consumption is linear in the size of the input, the constant factor is very large.
frisby attempts to address both these concerns.
frisby parsers achieve composability by having a compilation
pass,
recursive parsers are specified using the recursive do notation 'mdo' which
builds up a description of your parser where the recursive calls for which
memoized entries must be made are explicit. then runPeg
takes this
description and compiles it into a form that can be applied, during this
compilation step it examines your composed parser, and collects the global
table of rules needed for a packrat parser to work.
Memory consumption is much less of an issue on modern machines; tests show it is not a major concern, however frisby uses a couple of techniques for reducing the impact. First it attempts to create parsers that are as lazy as possible  this means that no more of the file is read into memory than is needed, and more importantly, memory used by the parser can be reclaimed as you process its output.
frisby also attempts to optimize
your parser, using specialized strategies
when allowed to reduce the number of entries in your memoization tables.
frisby attempts to be lazy in reading the results of parsers, parsers tend to work via sending out 'feeler' predicates to get an idea of what the rest of the file looks like before deciding what pass to take, frisby attempts to optimize these feeler predicates via extra lazyness such that they do not cause the actual computation of the results, but rather just compute enough to determine whether a predicate would have succeeded or not.
(It is interesting to note that the memory efficiency of frisby depends vitally on being as lazy as possible, in contrast to traditional thoughts when it comes to memory consumption)
frisby is a work in progress, it has a darcs repo at http://repetae.net/repos/frisby which may be browsed at http://repetae.net/dw/darcsweb.cgi?r=frisby;a=summary
And its homepage is at http://repetae.net/computer/frisby
To learn more about PEG parsers, see this paper http://pdos.csail.mit.edu/~baford/packrat/popl04 and Bryan Ford's packrat parsing page http://pdos.csail.mit.edu/~baford/packrat/
Synopsis
 data P s a
 data PM s a
 newRule :: P s a > PM s (P s a)
 runPeg :: (forall s. PM s (P s a)) > String > a
 (<$) :: Functor f => a > f b > f a
 class Functor f => Applicative (f :: Type > Type) where
 newtype WrappedMonad (m :: Type > Type) a = WrapMonad {
 unwrapMonad :: m a
 newtype WrappedArrow (a :: Type > Type > Type) b c = WrapArrow {
 unwrapArrow :: a b c
 newtype ZipList a = ZipList {
 getZipList :: [a]
 newtype Const a (b :: k) :: forall k. Type > k > Type = Const {
 getConst :: a
 (<$>) :: Functor f => (a > b) > f a > f b
 liftA3 :: Applicative f => (a > b > c > d) > f a > f b > f c > f d
 liftA :: Applicative f => (a > b) > f a > f b
 (<**>) :: Applicative f => f a > f (a > b) > f b
 class Applicative f => Alternative (f :: Type > Type) where
 (//) :: P s a > P s a > P s a
 (<>) :: P s a > P s b > P s (a, b)
 (<++>) :: P s [a] > P s [a] > P s [a]
 (>>) :: P s a > P s b > P s b
 (<<) :: P s a > P s b > P s a
 (//>) :: P s a > a > P s a
 (##) :: P s a > (a > b) > P s b
 (##>) :: P s a > b > P s b
 anyChar :: P s Char
 bof :: P s ()
 eof :: P s ()
 getPos :: P s Int
 char :: Char > P s Char
 noneOf :: [Char] > P s Char
 oneOf :: [Char] > P s Char
 text :: String > P s String
 unit :: a > P s a
 rest :: P s String
 discard :: P s a > P s ()
 parseFailure :: P s a
 peek :: P s a > P s a
 doesNotMatch :: P s a > P s ()
 isMatch :: P s a > P s Bool
 onlyIf :: P s a > (a > Bool) > P s a
 matches :: P s a > P s ()
 many :: P s a > P s [a]
 many1 :: P s a > P s [a]
 manyUntil :: P s b > P s a > PM s (P s [a])
 between :: P s a > P s b > P s c > P s c
 choice :: [P s a] > P s a
 option :: a > P s a > P s a
 optional :: P s a > P s ()
 newRegex :: MonadFail m => String > m (PM s (P s String))
 regex :: String > PM s (P s String)
 showRegex :: String > IO ()
The basic types
The type of primitive parsers
The monad used to create recursive parsers via rules
newRule :: P s a > PM s (P s a) Source #
Create a new rule, which may be used recursively and caches its results.
This is intended to be use in an 'mdo' block. such as the following.
additive = mdo additive < newRule $ multitive <> char '+' >> additive ## uncurry (+) // multitive multitive < newRule $ primary <> char '*' >> multitive ## uncurry (*) // primary primary < newRule $ char '(' >> additive << char ')' // decimal decimal < newRule $ many1 (oneOf ['0' .. '9']) ## read return additive
All recursive calls must be bound via a rule. Left recursion should be avoided.
runPeg :: (forall s. PM s (P s a)) > String > a Source #
Run a PEG grammar. Takes the rank2 argument in order to ensure a rule created in one PM session isn't returned and used in another PEG parser.
There is no need for special error handling, as it can be trivially implemented via
 parse complete file, returning 'Nothing' if parse fails fmap Just (myParser << eof) // unit Nothing
There is also no need for the parser to return its unused input, as that can be retrieved via rest
.
 Now this returns (a,String) where String is the unconsumed input. myParser <> rest
class Functor f => Applicative (f :: Type > Type) where #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*>
or liftA2
. If it defines both, then they must behave
the same as their default definitions:
(<*>
) =liftA2
id
liftA2
f x y = f<$>
x<*>
y
Further, any definition must satisfy the following:
 identity
pure
id
<*>
v = v composition
pure
(.)<*>
u<*>
v<*>
w = u<*>
(v<*>
w) homomorphism
pure
f<*>
pure
x =pure
(f x) interchange
u
<*>
pure
y =pure
($
y)<*>
u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor
instance for f
will satisfy
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2
p (liftA2
q u v) =liftA2
f u .liftA2
g v
If f
is also a Monad
, it should satisfy
(which implies that pure
and <*>
satisfy the applicative functor laws).
Lift a value.
(<*>) :: f (a > b) > f a > f b infixl 4 #
Sequential application.
A few functors support an implementation of <*>
that is more
efficient than the default one.
liftA2 :: (a > b > c) > f a > f b > f c #
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more
efficient than the default one. In particular, if fmap
is an
expensive operation, it is likely better to use liftA2
than to
fmap
over the structure and then use <*>
.
(*>) :: f a > f b > f b infixl 4 #
Sequence actions, discarding the value of the first argument.
(<*) :: f a > f b > f a infixl 4 #
Sequence actions, discarding the value of the second argument.
Instances
Applicative []  Since: base2.1 
Applicative Maybe  Since: base2.1 
Applicative IO  Since: base2.1 
Applicative Min  Since: base4.9.0.0 
Applicative Max  Since: base4.9.0.0 
Applicative First  Since: base4.9.0.0 
Applicative Last  Since: base4.9.0.0 
Applicative Option  Since: base4.9.0.0 
Applicative ZipList  f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN = 'ZipList' (zipWithN f xs1 ... xsN) where (\a b c > stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c > stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base2.1 
Applicative Identity  Since: base4.8.0.0 
Applicative First  Since: base4.8.0.0 
Applicative Last  Since: base4.8.0.0 
Applicative Dual  Since: base4.8.0.0 
Applicative Sum  Since: base4.8.0.0 
Applicative Product  Since: base4.8.0.0 
Applicative ReadP  Since: base4.6.0.0 
Applicative NonEmpty  Since: base4.9.0.0 
Applicative P  Since: base4.5.0.0 
Applicative (Either e)  Since: base3.0 
Monoid a => Applicative ((,) a)  For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: base2.1 
Monad m => Applicative (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative pure :: a > WrappedMonad m a # (<*>) :: WrappedMonad m (a > b) > WrappedMonad m a > WrappedMonad m b # liftA2 :: (a > b > c) > WrappedMonad m a > WrappedMonad m b > WrappedMonad m c # (*>) :: WrappedMonad m a > WrappedMonad m b > WrappedMonad m b # (<*) :: WrappedMonad m a > WrappedMonad m b > WrappedMonad m a #  
Applicative (P s) Source #  
Applicative (PM s) Source #  
Arrow a => Applicative (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative pure :: a0 > WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 > b0) > WrappedArrow a b a0 > WrappedArrow a b b0 # liftA2 :: (a0 > b0 > c) > WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b c # (*>) :: WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b a0 #  
Monoid m => Applicative (Const m :: Type > Type)  Since: base2.0.1 
Applicative f => Applicative (Ap f)  Since: base4.12.0.0 
Applicative f => Applicative (Alt f)  Since: base4.8.0.0 
Applicative m => Applicative (IdentityT m)  
Defined in Control.Monad.Trans.Identity  
(Functor m, Monad m) => Applicative (ErrorT e m)  
Defined in Control.Monad.Trans.Error  
(Functor m, Monad m) => Applicative (StateT s m)  
Defined in Control.Monad.Trans.State.Lazy  
Applicative ((>) a :: Type > Type)  Since: base2.1 
(Applicative f, Monad f) => Applicative (WhenMissing f k x)  Equivalent to Since: containers0.5.9 
Defined in Data.Map.Internal pure :: a > WhenMissing f k x a # (<*>) :: WhenMissing f k x (a > b) > WhenMissing f k x a > WhenMissing f k x b # liftA2 :: (a > b > c) > WhenMissing f k x a > WhenMissing f k x b > WhenMissing f k x c # (*>) :: WhenMissing f k x a > WhenMissing f k x b > WhenMissing f k x b # (<*) :: WhenMissing f k x a > WhenMissing f k x b > WhenMissing f k x a #  
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)  Equivalent to Since: containers0.5.9 
Defined in Data.Map.Internal pure :: a > WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a > b) > WhenMatched f k x y a > WhenMatched f k x y b # liftA2 :: (a > b > c) > WhenMatched f k x y a > WhenMatched f k x y b > WhenMatched f k x y c # (*>) :: WhenMatched f k x y a > WhenMatched f k x y b > WhenMatched f k x y b # (<*) :: WhenMatched f k x y a > WhenMatched f k x y b > WhenMatched f k x y a # 
newtype WrappedMonad (m :: Type > Type) a #
WrapMonad  

Instances
newtype WrappedArrow (a :: Type > Type > Type) b c #
WrapArrow  

Instances
Lists, but with an Applicative
functor based on zipping.
ZipList  

Instances
Functor ZipList  Since: base2.1 
Applicative ZipList  f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN = 'ZipList' (zipWithN f xs1 ... xsN) where (\a b c > stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c > stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base2.1 
Foldable ZipList  Since: base4.9.0.0 
Defined in Control.Applicative fold :: Monoid m => ZipList m > m # foldMap :: Monoid m => (a > m) > ZipList a > m # foldr :: (a > b > b) > b > ZipList a > b # foldr' :: (a > b > b) > b > ZipList a > b # foldl :: (b > a > b) > b > ZipList a > b # foldl' :: (b > a > b) > b > ZipList a > b # foldr1 :: (a > a > a) > ZipList a > a # foldl1 :: (a > a > a) > ZipList a > a # elem :: Eq a => a > ZipList a > Bool # maximum :: Ord a => ZipList a > a # minimum :: Ord a => ZipList a > a #  
Traversable ZipList  Since: base4.9.0.0 
Alternative ZipList  Since: base4.11.0.0 
Eq a => Eq (ZipList a)  Since: base4.7.0.0 
Ord a => Ord (ZipList a)  Since: base4.7.0.0 
Defined in Control.Applicative  
Read a => Read (ZipList a)  Since: base4.7.0.0 
Show a => Show (ZipList a)  Since: base4.7.0.0 
Generic (ZipList a)  
Generic1 ZipList  
type Rep (ZipList a)  Since: base4.7.0.0 
Defined in Control.Applicative  
type Rep1 ZipList  Since: base4.7.0.0 
Defined in Control.Applicative 
newtype Const a (b :: k) :: forall k. Type > k > Type #
The Const
functor.
Instances
Generic1 (Const a :: k > Type)  
Functor (Const m :: Type > Type)  Since: base2.1 
Monoid m => Applicative (Const m :: Type > Type)  Since: base2.0.1 
Foldable (Const m :: Type > Type)  Since: base4.7.0.0 
Defined in Data.Functor.Const fold :: Monoid m0 => Const m m0 > m0 # foldMap :: Monoid m0 => (a > m0) > Const m a > m0 # foldr :: (a > b > b) > b > Const m a > b # foldr' :: (a > b > b) > b > Const m a > b # foldl :: (b > a > b) > b > Const m a > b # foldl' :: (b > a > b) > b > Const m a > b # foldr1 :: (a > a > a) > Const m a > a # foldl1 :: (a > a > a) > Const m a > a # elem :: Eq a => a > Const m a > Bool # maximum :: Ord a => Const m a > a # minimum :: Ord a => Const m a > a #  
Traversable (Const m :: Type > Type)  Since: base4.7.0.0 
Bounded a => Bounded (Const a b)  Since: base4.9.0.0 
Enum a => Enum (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const succ :: Const a b > Const a b # pred :: Const a b > Const a b # fromEnum :: Const a b > Int # enumFrom :: Const a b > [Const a b] # enumFromThen :: Const a b > Const a b > [Const a b] # enumFromTo :: Const a b > Const a b > [Const a b] # enumFromThenTo :: Const a b > Const a b > Const a b > [Const a b] #  
Eq a => Eq (Const a b)  Since: base4.9.0.0 
Floating a => Floating (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const exp :: Const a b > Const a b # log :: Const a b > Const a b # sqrt :: Const a b > Const a b # (**) :: Const a b > Const a b > Const a b # logBase :: Const a b > Const a b > Const a b # sin :: Const a b > Const a b # cos :: Const a b > Const a b # tan :: Const a b > Const a b # asin :: Const a b > Const a b # acos :: Const a b > Const a b # atan :: Const a b > Const a b # sinh :: Const a b > Const a b # cosh :: Const a b > Const a b # tanh :: Const a b > Const a b # asinh :: Const a b > Const a b # acosh :: Const a b > Const a b # atanh :: Const a b > Const a b # log1p :: Const a b > Const a b # expm1 :: Const a b > Const a b #  
Fractional a => Fractional (Const a b)  Since: base4.9.0.0 
Integral a => Integral (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const  
Num a => Num (Const a b)  Since: base4.9.0.0 
Ord a => Ord (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const  
Read a => Read (Const a b)  This instance would be equivalent to the derived instances of the
Since: base4.8.0.0 
Real a => Real (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const toRational :: Const a b > Rational #  
RealFloat a => RealFloat (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const floatRadix :: Const a b > Integer # floatDigits :: Const a b > Int # floatRange :: Const a b > (Int, Int) # decodeFloat :: Const a b > (Integer, Int) # encodeFloat :: Integer > Int > Const a b # exponent :: Const a b > Int # significand :: Const a b > Const a b # scaleFloat :: Int > Const a b > Const a b # isInfinite :: Const a b > Bool # isDenormalized :: Const a b > Bool # isNegativeZero :: Const a b > Bool #  
RealFrac a => RealFrac (Const a b)  Since: base4.9.0.0 
Show a => Show (Const a b)  This instance would be equivalent to the derived instances of the
Since: base4.8.0.0 
Ix a => Ix (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const range :: (Const a b, Const a b) > [Const a b] # index :: (Const a b, Const a b) > Const a b > Int # unsafeIndex :: (Const a b, Const a b) > Const a b > Int inRange :: (Const a b, Const a b) > Const a b > Bool # rangeSize :: (Const a b, Const a b) > Int # unsafeRangeSize :: (Const a b, Const a b) > Int  
Generic (Const a b)  
Semigroup a => Semigroup (Const a b)  Since: base4.9.0.0 
Monoid a => Monoid (Const a b)  Since: base4.9.0.0 
Storable a => Storable (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const  
Bits a => Bits (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const (.&.) :: Const a b > Const a b > Const a b # (..) :: Const a b > Const a b > Const a b # xor :: Const a b > Const a b > Const a b # complement :: Const a b > Const a b # shift :: Const a b > Int > Const a b # rotate :: Const a b > Int > Const a b # setBit :: Const a b > Int > Const a b # clearBit :: Const a b > Int > Const a b # complementBit :: Const a b > Int > Const a b # testBit :: Const a b > Int > Bool # bitSizeMaybe :: Const a b > Maybe Int # isSigned :: Const a b > Bool # shiftL :: Const a b > Int > Const a b # unsafeShiftL :: Const a b > Int > Const a b # shiftR :: Const a b > Int > Const a b # unsafeShiftR :: Const a b > Int > Const a b # rotateL :: Const a b > Int > Const a b #  
FiniteBits a => FiniteBits (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const finiteBitSize :: Const a b > Int # countLeadingZeros :: Const a b > Int # countTrailingZeros :: Const a b > Int #  
type Rep1 (Const a :: k > Type)  Since: base4.9.0.0 
Defined in Data.Functor.Const  
type Rep (Const a b)  Since: base4.9.0.0 
Defined in Data.Functor.Const 
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 #
An infix synonym for fmap
.
The name of this operator is an allusion to $
.
Note the similarities between their types:
($) :: (a > b) > a > b (<$>) :: Functor f => (a > b) > f a > f b
Whereas $
is function application, <$>
is function
application lifted over a Functor
.
Examples
Convert from a
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an Either
Int
Int
Either
Int
String
using show
:
>>>
show <$> Left 17
Left 17>>>
show <$> Right 17
Right "17"
Double each element of a list:
>>>
(*2) <$> [1,2,3]
[2,4,6]
Apply even
to the second element of a pair:
>>>
even <$> (2,2)
(2,True)
liftA3 :: Applicative f => (a > b > c > d) > f a > f b > f c > f d #
Lift a ternary function to actions.
liftA :: Applicative f => (a > b) > f a > f b #
(<**>) :: Applicative f => f a > f (a > b) > f b infixl 4 #
A variant of <*>
with the arguments reversed.
class Applicative f => Alternative (f :: Type > Type) where #
A monoid on applicative functors.
If defined, some
and many
should be the least solutions
of the equations:
Instances
Basic operators
(//) :: P s a > P s a > P s a infixl 1 Source #
Ordered choice, try left argument, if it fails try the right one. This does not introduce any backtracking or penalty.
(<>) :: P s a > P s b > P s (a, b) infixl 3 Source #
Match first argument, then match the second, returning both in a tuple
Derived operators
(>>) :: P s a > P s b > P s b infixl 4 Source #
Match first argument, then match the second, returning only the value on the right.
x >> y = x <> y ## snd
(<<) :: P s a > P s b > P s a infixl 4 Source #
Match first argument, then match the second, returning only the value on the left.
x << y = x <> y ## fst
(//>) :: P s a > a > P s a infixl 1 Source #
Ordered choice, try left argument, if it fails then return right argument.
Modification operators
(##) :: P s a > (a > b) > P s b infix 2 Source #
Map a parser through a function. a fancy version of fmap
.
Basic combinators
Immediately consume and return the rest of the input equivalent to (many anyChar), but more efficient.
parseFailure :: P s a Source #
Fails, is identity of (//) and unit of (<>).
Speculative combinators
These are how a frisby parser decides what path to take, whereas a backtracking parser might try a path, then backtrack if it got it wrong, a frisby parser can look at all possible paths before deciding which one to take via these predicates. this is what allows much of the power of packrat parsing, a parser is free to evaluate every alternative fully before committing to a particular path.
Packrat parsers have no past, but can 'see' arbitrarily far into all of its potential futures, traditional monadic parsers can accumulate a history, but cannot see more than a token or two into the future, and evaluating multiple futures to any degree imposes a significant runtime penalty due to backtracking.
doesNotMatch :: P s a > P s () Source #
Succeeds when the argument does not.
matches :: P s a > P s () Source #
Succeeds when the argument does, but consumes no input. Equivalant to p > discard (peek p)
Looping combinators
many :: P s a > P s [a] Source #
Parse many of something. Behaves like * in regexes.
This eats as much as it possibly can, if you want a minimal much rule, then use manyUntil
which stops when a.
manyUntil :: P s b > P s a > PM s (P s [a]) Source #
Parse many of something via the minimal munch rule. behaves like *? in perl regexes. The final item is not consumed.
Various utility combinators
between :: P s a > P s b > P s c > P s c Source #
Equivalent to
between open close thing = open >> thing << close
option :: a > P s a > P s a Source #
Parse something if you can, else return first value
option a p = p // unit a
optional :: P s a > P s () Source #
Parse something if you can, discarding it.
option a p = discard p // unit ()
Regular expression syntax
Take a string in extended regex format and return a frisby parser that has the same behavior.
The behavior is slightly different than POSIX regular expressions.
frisby regular expressions always follow the true
maximal or minimal munch
rules, rather than the (unuseful and inefficient) greedy rule of POSIX regexs.
What this means is something like
x*x
will never match, because the first x*
will munch every x available so the second won't match.
Minimal munching can be expressed like in perl,
.*?y
will grab everything up to the next y. In posix it would grab everything up til the last y in the file.
These are much more natural semantics and much more efficient to implement.
newRegex :: MonadFail m => String > m (PM s (P s String)) Source #
Create a new regular expression matching parser. it returns something in a possibly failing monad to indicate an error in the regular expression itself.