Copyright | (c) Matthew Sackman Ivan Lazar Miljenovic |
---|---|
License | 3-Clause BSD-style |
Maintainer | Ivan.Miljenovic@gmail.com |
Safe Haskell | Safe |
Language | Haskell2010 |
Data.GraphViz.Parsing
Description
This module defines simple helper functions for use with Text.ParserCombinators.Poly.Lazy.
Note that the ParseDot
instances for Bool
, etc. match those
specified for use with Graphviz (e.g. non-zero integers are
equivalent to True
).
You should not be using this module; rather, it is here for
informative/documentative reasons. If you want to parse a
, you should use
DotRepr
rather than its parseDotGraph
ParseDot
instance.
Synopsis
- (<$) :: Functor f => a -> f b -> f a
- class Functor f => Applicative (f :: Type -> Type) where
- class Applicative f => Alternative (f :: Type -> Type) where
- newtype Const a (b :: k) = Const {
- getConst :: a
- newtype ZipList a = ZipList {
- getZipList :: [a]
- newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
- newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
- 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
- optional :: Alternative f => f a -> f (Maybe a)
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- reparse :: Text -> Parser s ()
- stGet :: Parser s s
- stQuery :: (s -> a) -> Parser s a
- stUpdate :: (s -> s) -> Parser s ()
- many1Satisfy :: (Char -> Bool) -> Parser s Text
- manySatisfy :: (Char -> Bool) -> Parser s Text
- onFail :: Parser s a -> Parser s a -> Parser s a
- satisfy :: (Char -> Bool) -> Parser s Char
- eof :: Parser s ()
- next :: Parser s Char
- newtype Parser s a = P (s -> Text -> Result (Text, s) a)
- data Result z a
- manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a]
- manyFinally :: PolyParse p => p a -> p z -> p [a]
- bracket :: PolyParse p => p bra -> p ket -> p a -> p a
- bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]
- sepBy1 :: PolyParse p => p a -> p sep -> p [a]
- sepBy :: PolyParse p => p a -> p sep -> p [a]
- many1 :: PolyParse p => p a -> p [a]
- upto :: PolyParse p => Int -> p a -> p [a]
- exactly :: PolyParse p => Int -> p a -> p [a]
- oneOf :: PolyParse p => [p a] -> p a
- adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a
- failBad :: PolyParse p => String -> p a
- discard :: PolyParse p => p a -> p b -> p a
- apply :: PolyParse p => p (a -> b) -> p a -> p b
- class Commitment (p :: Type -> Type) where
- class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type)
- type Parse a = Parser GraphvizState a
- class ParseDot a where
- parseIt :: ParseDot a => Text -> (a, Text)
- parseIt' :: ParseDot a => Text -> a
- runParser :: Parse a -> Text -> (Either String a, Text)
- runParser' :: Parse a -> Text -> a
- runParserWith :: (GraphvizState -> GraphvizState) -> Parse a -> Text -> (Either String a, Text)
- parseLiberally :: GraphvizState -> GraphvizState
- checkValidParse :: Either String a -> a
- checkValidParseWithRest :: (Either String a, Text) -> a
- ignoreSep :: (a -> b -> c) -> Parse a -> Parse sep -> Parse b -> Parse c
- onlyBool :: Parse Bool
- quotelessString :: Parse Text
- stringBlock :: Parse Text
- numString :: Bool -> Parse Text
- isNumString :: Bool -> Text -> Bool
- isIntString :: Text -> Bool
- quotedString :: Parse Text
- parseEscaped :: Bool -> [Char] -> [Char] -> Parse Text
- parseAndSpace :: Parse a -> Parse a
- string :: String -> Parse ()
- strings :: [String] -> Parse ()
- character :: Char -> Parse Char
- parseStrictFloat :: Bool -> Parse Double
- parseSignedFloat :: Bool -> Parse Double
- noneOf :: [Char] -> Parse Char
- whitespace1 :: Parse ()
- whitespace :: Parse ()
- wrapWhitespace :: Parse a -> Parse a
- optionalQuotedString :: String -> Parse ()
- optionalQuoted :: Parse a -> Parse a
- quotedParse :: Parse a -> Parse a
- orQuote :: Parse Char -> Parse Char
- quoteChar :: Char
- newline :: Parse ()
- newline' :: Parse ()
- parseComma :: Parse ()
- parseEq :: Parse ()
- tryParseList :: ParseDot a => Parse [a]
- tryParseList' :: Parse [a] -> Parse [a]
- consumeLine :: Parse Text
- commaSep :: (ParseDot a, ParseDot b) => Parse (a, b)
- commaSepUnqt :: (ParseDot a, ParseDot b) => Parse (a, b)
- commaSep' :: Parse a -> Parse b -> Parse (a, b)
- stringRep :: a -> String -> Parse a
- stringReps :: a -> [String] -> Parse a
- stringParse :: [(String, Parse a)] -> Parse a
- stringValue :: [(String, a)] -> Parse a
- parseAngled :: Parse a -> Parse a
- parseBraced :: Parse a -> Parse a
- parseColorScheme :: Bool -> Parse ColorScheme
Re-exporting pertinent parts of Polyparse.
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative [] | |
Applicative Maybe | |
Applicative IO | |
Applicative Par1 | |
Applicative Q | |
Applicative RGB | |
Applicative DList | |
Applicative Tree | |
Applicative ZipList | |
Applicative NonEmpty | |
Applicative ReadPrec | |
Applicative P | |
Applicative ReadP | |
Applicative Dual | |
Applicative Product | |
Applicative Sum | |
Applicative Down | |
Applicative First | |
Applicative Last | |
Applicative Identity | |
Applicative DotCodeM Source # | |
Applicative Put | |
Applicative Seq | |
Applicative STM | |
Applicative (Either e) | |
Applicative (U1 :: Type -> Type) | |
Monoid a => Applicative ((,) a) | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods 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 (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
Applicative (Proxy :: Type -> Type) | |
Applicative (IParser t) | |
Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
Applicative m => Applicative (ListT m) | |
(Functor m, Monad m) => Applicative (MaybeT m) | |
Applicative (DotM n) Source # | |
Applicative f => Applicative (Rec1 f) | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods 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 # | |
Applicative f => Applicative (Alt f) | |
Applicative f => Applicative (Ap f) | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
Applicative ((->) a :: Type -> Type) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
Applicative (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods 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 x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
Applicative f => Applicative (M1 i c f) | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods 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 # |
class Applicative f => Alternative (f :: Type -> Type) where #
Minimal complete definition
empty, (<|>)
Instances
Alternative [] | |
Alternative Maybe | |
Alternative IO | |
Alternative DList | |
Alternative ZipList | |
Alternative ReadPrec | |
Alternative P | |
Alternative ReadP | |
Alternative Seq | |
Alternative STM | |
Alternative (U1 :: Type -> Type) | |
MonadPlus m => Alternative (WrappedMonad m) | |
Defined in Control.Applicative Methods empty :: WrappedMonad m a (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |
Alternative (Parser s) | |
Alternative (Proxy :: Type -> Type) | |
ArrowPlus a => Alternative (ArrowMonad a) | |
Applicative m => Alternative (ListT m) | |
(Functor m, Monad m) => Alternative (MaybeT m) | |
Alternative f => Alternative (Rec1 f) | |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |
Alternative f => Alternative (Alt f) | |
Alternative f => Alternative (Ap f) | |
(Functor m, MonadPlus m) => Alternative (StateT s m) | |
(Functor m, Monad m, Error e) => Alternative (ErrorT e m) | |
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |
Alternative m => Alternative (IdentityT m) | |
Alternative m => Alternative (ReaderT r m) | |
(Functor m, MonadPlus m) => Alternative (StateT s m) | |
(Monoid w, Alternative m) => Alternative (WriterT w m) | |
(Monoid w, Alternative m) => Alternative (WriterT w m) | |
(Alternative f, Alternative g) => Alternative (f :*: g) | |
Alternative f => Alternative (M1 i c f) | |
(Alternative f, Applicative g) => Alternative (f :.: g) | |
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) | |
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) | |
Instances
Generic1 (Const a :: k -> Type) | |
Eq2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes | |
Ord2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering | |
Read2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] | |
Show2 (Const :: Type -> Type -> Type) | |
Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS | |
Functor (Const m :: Type -> Type) | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> 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) | |
Defined in Data.Traversable | |
Eq a => Eq1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes | |
Ord a => Ord1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering | |
Show a => Show1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS | |
Read a => Read1 (Const a :: Type -> Type) | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] | |
Bounded a => Bounded (Const a b) | |
Defined in Data.Functor.Const | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const | |
Eq a => Eq (Const a b) | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods 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 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) | |
Defined in Data.Functor.Const | |
Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const | |
Num a => Num (Const a b) | |
Ord a => Ord (Const a b) | |
Defined in Data.Functor.Const | |
Read a => Read (Const a b) | |
Defined in Data.Functor.Const | |
Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational | |
RealFloat a => RealFloat (Const a b) | |
Defined in Data.Functor.Const Methods 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 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) | |
Show a => Show (Const a b) | |
Ix a => Ix (Const a b) | |
Defined in Data.Functor.Const Methods 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 | |
IsString a => IsString (Const a b) | |
Defined in Data.String Methods fromString :: String -> Const a b | |
Generic (Const a b) | |
Semigroup a => Semigroup (Const a b) | |
Monoid a => Monoid (Const a b) | |
Bits a => Bits (Const a b) | |
Defined in Data.Functor.Const Methods (.&.) :: 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 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) | |
Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int countLeadingZeros :: Const a b -> Int countTrailingZeros :: Const a b -> Int | |
Storable a => Storable (Const a b) | |
Defined in Data.Functor.Const Methods peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () peekByteOff :: Ptr b0 -> Int -> IO (Const a b) pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () | |
type Rep1 (Const a :: k -> Type) | |
Defined in Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))) | |
type Rep (Const a b) | |
Defined in Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))) |
Constructors
ZipList | |
Fields
|
Instances
Functor ZipList | |
Applicative ZipList | |
Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> 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 | |
Defined in Data.Traversable | |
Alternative ZipList | |
Eq a => Eq (ZipList a) | |
Ord a => Ord (ZipList a) | |
Defined in Control.Applicative | |
Read a => Read (ZipList a) | |
Defined in Control.Applicative | |
Show a => Show (ZipList a) | |
Generic (ZipList a) | |
Generic1 ZipList | |
type Rep (ZipList a) | |
Defined in Control.Applicative type Rep (ZipList a) = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a]))) | |
type Rep1 ZipList | |
Defined in Control.Applicative type Rep1 ZipList = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 []))) |
newtype WrappedMonad (m :: Type -> Type) a #
Constructors
WrapMonad | |
Fields
|
Instances
Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b return :: a -> WrappedMonad m a | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b (<$) :: a -> WrappedMonad m b -> WrappedMonad m a # | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods 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 # | |
MonadPlus m => Alternative (WrappedMonad m) | |
Defined in Control.Applicative Methods empty :: WrappedMonad m a (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] # | |
Generic1 (WrappedMonad m :: Type -> Type) | |
Defined in Control.Applicative Associated Types type Rep1 (WrappedMonad m) :: k -> Type Methods from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a | |
Generic (WrappedMonad m a) | |
Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x to :: Rep (WrappedMonad m a) x -> WrappedMonad m a | |
type Rep1 (WrappedMonad m :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedMonad m :: Type -> Type) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 m))) | |
type Rep (WrappedMonad m a) | |
Defined in Control.Applicative type Rep (WrappedMonad m a) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m a)))) |
newtype WrappedArrow (a :: Type -> Type -> Type) b c #
Constructors
WrapArrow | |
Fields
|
Instances
Generic1 (WrappedArrow a b :: Type -> Type) | |
Defined in Control.Applicative Associated Types type Rep1 (WrappedArrow a b) :: k -> Type Methods from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods 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 # | |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # | |
Generic (WrappedArrow a b c) | |
Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c | |
type Rep1 (WrappedArrow a b :: Type -> Type) | |
Defined in Control.Applicative type Rep1 (WrappedArrow a b :: Type -> Type) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (a b)))) | |
type Rep (WrappedArrow a b c) | |
Defined in Control.Applicative type Rep (WrappedArrow a b c) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a b c)))) |
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 #
optional :: Alternative f => f a -> f (Maybe a) #
reparse :: Text -> Parser s () Source #
Push some tokens back onto the front of the input stream and reparse. This is useful e.g. for recursively expanding macros. When the user-parser recognises a macro use, it can lookup the macro expansion from the parse state, lex it, and then stuff the lexed expansion back down into the parser.
many1Satisfy :: (Char -> Bool) -> Parser s Text Source #
many1Satisfy p
is a more efficient fused version of many1 (satisfy p)
manySatisfy :: (Char -> Bool) -> Parser s Text Source #
manySatisfy p
is a more efficient fused version of many (satisfy p)
onFail :: Parser s a -> Parser s a -> Parser s a Source #
p
means parse p, unless p fails, in which case
parse q instead.
Can be chained together to give multiple attempts to parse something.
(Note that q could itself be a failing parser, e.g. to change the error
message from that defined in p to something different.)
However, a severe failure in p cannot be ignored.onFail
q
satisfy :: (Char -> Bool) -> Parser s Char Source #
Return the next token if it satisfies the given predicate.
This Parser
datatype is a specialised parsing monad with error
reporting. Whereas the standard version can be used for arbitrary
token types, this version is specialised to Text input only.
Instances
Monad (Parser s) | |
Functor (Parser s) | |
MonadFail (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
Applicative (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText | |
Alternative (Parser s) | |
Commitment (Parser s) | |
PolyParse (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText |
A return type like Either, that distinguishes not only between right and wrong answers, but also has commitment, so that a failure cannot be undone. This should only be used for writing very primitive parsers - really it is an internal detail of the library. The z type is the remaining unconsumed input.
manyFinally' :: (PolyParse p, Show a) => p a -> p z -> p [a] Source #
manyFinally'
is like manyFinally
, except when the terminator
parser overlaps with the element parser. In manyFinally e t
,
the parser t
is tried only when parser e
fails, whereas in
manyFinally' e t
, the parser t
is always tried first, then
parser e
only if the terminator is not found. For instance,
manyFinally (accept "01") (accept "0")
on input "0101010"
returns
["01","01","01"]
, whereas manyFinally'
with the same arguments
and input returns []
.
manyFinally :: PolyParse p => p a -> p z -> p [a] Source #
manyFinally e t
parses a possibly-empty sequence of e
's,
terminated by a t
. The final t
is discarded. Any parse failures
could be due either to a badly-formed terminator or a badly-formed
element, so it raises both possible errors.
bracket :: PolyParse p => p bra -> p ket -> p a -> p a Source #
Parse a bracketed item, discarding the brackets.
If everything matches except the closing bracket, the whole
parse fails soft, which can give less-than-satisfying error messages.
If you want better error messages, try calling with e.g.
bracket open (commit close) item
bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] Source #
Parse a list of items, discarding the start, end, and separator items.
sepBy1 :: PolyParse p => p a -> p sep -> p [a] Source #
Parse a non-empty list of items separated by discarded junk.
sepBy :: PolyParse p => p a -> p sep -> p [a] Source #
Parse a list of items separated by discarded junk.
upto :: PolyParse p => Int -> p a -> p [a] Source #
'upto n p' parses n or fewer items, using the parser p, in sequence.
exactly :: PolyParse p => Int -> p a -> p [a] Source #
'exactly n p' parses precisely n items, using the parser p, in sequence.
adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a Source #
adjustErrBad
is just like adjustErr
except it also raises the
severity of the error.
failBad :: PolyParse p => String -> p a Source #
When a simple fail is not strong enough, use failBad for emphasis. An emphasised (severe) error cannot be overridden by choice operators.
discard :: PolyParse p => p a -> p b -> p a infixl 3 Source #
x
parses both x and y, but discards the result of y.
Rather like discard
yconst
lifted into parsers.
apply :: PolyParse p => p (a -> b) -> p a -> p b infixl 3 Source #
Apply a parsed function to a parsed value. Rather like ordinary function application lifted into parsers.
class Commitment (p :: Type -> Type) where Source #
The Commitment
class is an abstraction over all the current
concrete representations of monadic/applicative parser combinators in this
package. The common feature is two-level error-handling.
Some primitives must be implemented specific to each parser type
(e.g. depending on whether the parser has a running state, or
whether it is lazy). But given those primitives, large numbers of
combinators do not depend any further on the internal structure of
the particular parser.
Methods
Commit is a way of raising the severity of any errors found within its argument. Used in the middle of a parser definition, it means that any operations prior to commitment fail softly, but after commitment, they fail hard.
adjustErr :: p a -> (String -> String) -> p a Source #
p
applies the transformation adjustErr
ff
to any error message
generated in p
, having no effect if p
succeeds.
oneOf' :: [(String, p a)] -> p a Source #
Parse the first alternative that succeeds, but if none succeed, report only the severe errors, and if none of those, then report all the soft errors.
class (Functor p, Monad p, MonadFail p, Applicative p, Alternative p, Commitment p) => PolyParse (p :: Type -> Type) Source #
The PolyParse
class is an abstraction gathering all of the common
features that a two-level error-handling parser requires:
the applicative parsing interface, the monadic interface, and commitment.
There are two additional basic combinators that we expect to be implemented
afresh for every concrete type, but which (for technical reasons)
cannot be class methods. They are next
and satisfy
.
Instances
PolyParse (Parser s) | |
Defined in Text.ParserCombinators.Poly.StateText |
The ParseDot class.
class ParseDot a where Source #
Minimal complete definition
Methods
parseUnqtList :: Parse [a] Source #
Instances
parseIt :: ParseDot a => Text -> (a, Text) Source #
Parse the required value, returning also the rest of the input
Text
that hasn't been parsed (for debugging purposes).
parseIt' :: ParseDot a => Text -> a Source #
Parse the required value with the assumption that it will parse
all of the input Text
.
runParser' :: Parse a -> Text -> a Source #
A variant of runParser
where it is assumed that the provided
parsing function consumes all of the Text
input (with the
exception of whitespace at the end).
runParserWith :: (GraphvizState -> GraphvizState) -> Parse a -> Text -> (Either String a, Text) Source #
parseLiberally :: GraphvizState -> GraphvizState Source #
checkValidParse :: Either String a -> a Source #
If unable to parse Dot code properly, throw
a
GraphvizException
.
checkValidParseWithRest :: (Either String a, Text) -> a Source #
If unable to parse Dot code properly, throw
a
GraphvizException
, with the error containing the remaining
unparsed code..
Convenience parsing combinators.
ignoreSep :: (a -> b -> c) -> Parse a -> Parse sep -> Parse b -> Parse c Source #
The opposite of bracket
.
quotelessString :: Parse Text Source #
Parse a Text
that doesn't need to be quoted.
stringBlock :: Parse Text Source #
isNumString :: Bool -> Text -> Bool Source #
Determine if this String represents a number. Boolean parameter determines if exponents are considered part of numbers for this.
isIntString :: Text -> Bool Source #
quotedString :: Parse Text Source #
Used when quotes are explicitly required;
parseEscaped :: Bool -> [Char] -> [Char] -> Parse Text Source #
Parse a Text
where the provided Char
s (as well as "
and
\
) are escaped and the second list of Char
s are those that
are not permitted. Note: does not parse surrounding quotes. The
Bool
value indicates whether empty Text
s are allowed or not.
parseAndSpace :: Parse a -> Parse a Source #
character :: Char -> Parse Char Source #
Assumes that any letter is ASCII for case-insensitive comparisons.
parseStrictFloat :: Bool -> Parse Double Source #
Parse a floating point number that actually contains decimals. Bool flag indicates whether values that need to be quoted are parsed.
parseSignedFloat :: Bool -> Parse Double Source #
whitespace1 :: Parse () Source #
Parses at least one whitespace character.
whitespace :: Parse () Source #
Parses zero or more whitespace characters.
wrapWhitespace :: Parse a -> Parse a Source #
Parse and discard optional surrounding whitespace.
optionalQuotedString :: String -> Parse () Source #
optionalQuoted :: Parse a -> Parse a Source #
quotedParse :: Parse a -> Parse a Source #
Consume all whitespace and newlines until a line with non-whitespace is reached. The whitespace on that line is not consumed.
parseComma :: Parse () Source #
tryParseList :: ParseDot a => Parse [a] Source #
Try to parse a list of the specified type; returns an empty list if parsing fails.
tryParseList' :: Parse [a] -> Parse [a] Source #
Return an empty list if parsing a list fails.
consumeLine :: Parse Text Source #
Parses and returns all characters up till the end of the line, but does not touch the newline characters.
stringReps :: a -> [String] -> Parse a Source #
stringParse :: [(String, Parse a)] -> Parse a Source #
stringValue :: [(String, a)] -> Parse a Source #
parseAngled :: Parse a -> Parse a Source #
parseBraced :: Parse a -> Parse a Source #
parseColorScheme :: Bool -> Parse ColorScheme Source #