-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A parser combinator library for the Definitive framework
--   
--   A parser combinator library for the Definitive framework
@package definitive-parser
@version 1.2


-- | A module providing simple Parser combinator functionality. Useful for
--   small parsing tasks such as identifier parsing or command-line
--   argument parsing
module Language.Parser
newtype ParserT s m a
ParserT :: (StateT s (ListT m) a) -> ParserT s m a
type Parser c a = ParserT c Id a
newtype ParserA m s a
ParserA :: (ParserT s m a) -> ParserA m s a
_ParserA :: Iso (ParserA m s a) (ParserA m' s' a') (ParserT s m a) (ParserT s' m' a')
class Stream c s | s -> c
uncons :: Stream c s => s -> Maybe (c, s)
cons :: Stream c s => c -> s -> s

-- | Test if a Stream is empty
emptyStream :: Stream c s => s -> Bool
parserT :: (Functor n, Functor m) => Iso (ParserT s m a) (ParserT t n b) (s -> m [(s, a)]) (t -> n [(t, b)])
parser :: Iso (Parser s a) (Parser t b) (s -> [(s, a)]) (t -> [(t, b)])
ioParser :: Parser a b -> (a -> IO b)

-- | The <tt>(+)</tt> operator with lower priority
(<+>) :: Semigroup m => m -> m -> m
(>*>) :: Monad m => ParserT a m b -> ParserT b m c -> ParserT a m c
(<*<) :: Monad m => ParserT b m c -> ParserT a m b -> ParserT a m c
cut :: Monad m => ParserT s m a -> ParserT s m a

-- | Consume a token from the Stream
token :: (Monad m, Stream c s) => ParserT s m c

-- | Consume a token and succeed if it verifies a predicate
satisfy :: (Monad m, Stream c s) => (c -> Bool) -> ParserT s m c

-- | Parse a member of a set of values
oneOf :: (Eq c, Monad m, Foldable t, Stream c s) => t c -> ParserT s m c

-- | Parse anything but a member of a set
noneOf :: (Eq c, Monad m, Foldable t, Stream c s) => t c -> ParserT s m c

-- | Consume a single fixed token or fail.
single :: (Eq c, Monad m, Stream c s) => c -> ParserT s m ()

-- | Consume a structure of characters or fail
several :: (Eq c, Monad m, Foldable t, Stream c s) => t c -> ParserT s m ()

-- | The remaining Stream to parse
remaining :: Monad m => ParserT s m s

-- | Succeed only at the End Of Input.
eoi :: (Monad m, Stream c s) => ParserT s m ()
readable :: (Monad m, Read a) => ParserT String m a

-- | Parse a litteral decimal number
number :: (Monad m, Stream Char s, Num n) => ParserT s m n

-- | Parse a single decimal digit
digit :: (Monad m, Stream Char s) => ParserT s m Char
letter :: (Monad m, Stream Char s) => ParserT s m Char
alNum :: (Monad m, Stream Char s) => ParserT s m Char

-- | Parse a delimited string, unsing <tt>\\</tt> as the quoting character
quotedString :: (Monad m, Stream Char s) => Char -> ParserT s m String

-- | A single space
space :: (Monad m, Stream Char s) => ParserT s m Char

-- | Many spaces
spaces :: (Monad m, Stream Char s) => ParserT s m String

-- | The end of a line
eol :: (Monad m, Stream Char s) => ParserT s m ()

-- | Parse zero, one or more successive occurences of a parser.
many :: Monad m => ParserT c m a -> ParserT c m [a]

-- | Parse one or more successiveé occurences of a parser.
many1 :: Monad m => ParserT c m a -> ParserT c m [a]

-- | Parse zero or more successive occurences of a parser separated by
--   occurences of a second parser.
sepBy :: Monad m => ParserT c m a -> ParserT c m b -> ParserT c m [a]

-- | Parse one or more successive occurences of a parser separated by
--   occurences of a second parser.
sepBy1 :: Monad m => ParserT c m a -> ParserT c m b -> ParserT c m [a]

-- | Skip many occurences of a parser
skipMany :: Monad m => ParserT c m a -> ParserT c m ()

-- | Skip multiple occurences of a parser
skipMany1 :: Monad m => ParserT c m a -> ParserT c m ()

-- | Chain an operator with an initial value
chainl :: (Stream c s, Monad m) => ParserT s m a -> ParserT s m (a -> b -> a) -> ParserT s m b -> ParserT s m a

-- | Chain an operator with an initial value and several tail values.
chainr :: (Stream c s, Monad m) => ParserT s m a -> ParserT s m (b -> a -> a) -> ParserT s m b -> ParserT s m a

-- | Try to consume a parser. Return a default value when it fails.
option :: Monad m => a -> ParserT s m a -> ParserT s m a
instance Monad m => MonadError Void (ParserT c m)
instance Unit m => Unit (ParserT s m)
instance Functor m => Functor (ParserT s m)
instance Applicative m => Semigroup (ParserT s m a)
instance Applicative m => Monoid (ParserT s m a)
instance Monad m => Applicative (ParserT s m)
instance Monad m => Monad (ParserT s m)
instance MonadFix m => MonadFix (ParserT s m)
instance Monad m => MonadList (ParserT s m)
instance Monad m => MonadState s (ParserT s m)
instance MonadWriter w m => MonadWriter w (ParserT s m)
instance Monad m => Arrow (ParserA m)
instance Monad m => Choice (ParserA m)
instance Monad m => Split (ParserA m)
instance Monad m => Category (ParserA m)
instance ConcreteMonad (ParserT s)
instance MonadTrans (ParserT s)

module Language.Syntax.Regex
regex :: Parser String (Parser String ([(String, String)], String))
runRegex :: String -> String -> [([(String, String)], String)]

module Data.Syntax
type Env f = Map String (ThunkT f)
type ThunkT f = f (SyntaxT f)
data SyntaxT f
ValList :: [ThunkT f] -> SyntaxT f
Dictionary :: (Env f) -> SyntaxT f
Text :: String -> SyntaxT f
Quote :: (SyntaxT f) -> SyntaxT f
Function :: (ThunkT f -> ThunkT f) -> SyntaxT f
dict :: Traversal' (SyntaxT f) (Env f)
nil :: SyntaxT f
variable :: Unit f => String -> SyntaxT f -> SyntaxT f
funcall :: ThunkT f -> ThunkT f -> SyntaxT f
builtin :: Unit m => (ThunkT m -> ThunkT m) -> ThunkT m
builtin2 :: Unit m => (ThunkT m -> ThunkT m -> ThunkT m) -> ThunkT m
builtin3 :: Unit m => (ThunkT m -> ThunkT m -> ThunkT m -> ThunkT m) -> ThunkT m
shape :: SyntaxT f -> String
reduce :: MonadReader (Env m) m => SyntaxT m -> ThunkT m
lambda :: MonadReader (Env m) m => SyntaxT Id -> SyntaxT m -> (ThunkT m -> ThunkT m)
matchPat :: Monad f => SyntaxT Id -> (SyntaxT f -> f (Maybe [(String, SyntaxT f)]))
lambdaSum :: Monad m => [ThunkT m -> ThunkT m] -> ThunkT m -> ThunkT m
instance Show (ThunkT f) => Show (SyntaxT f)

module Language.Syntax.CmdArgs

-- | Each <a>OptDescr</a> describes a single option.
--   
--   The arguments to <a>Option</a> are:
--   
--   <ul>
--   <li>list of short option characters</li>
--   <li>list of long option strings (without "--")</li>
--   <li>argument descriptor</li>
--   <li>explanation of option for user</li>
--   </ul>
data OptDescr a :: * -> *
Option :: [Char] -> [String] -> ArgDescr a -> String -> OptDescr a

-- | Describes whether an option takes an argument or not, and if so how
--   the argument is injected into a value of type <tt>a</tt>.
data ArgDescr a :: * -> *

-- | no argument expected
NoArg :: a -> ArgDescr a

-- | option requires argument
ReqArg :: (String -> a) -> String -> ArgDescr a

-- | optional argument
OptArg :: (Maybe String -> a) -> String -> ArgDescr a

-- | Return a string describing the usage of a command, derived from the
--   header (first argument) and the options described by the second
--   argument.
usageInfo :: String -> [OptDescr a] -> String

-- | Create a Parser that preprocesses the command-line arguments,
--   splitting options and their arguments into a user-defined data type.
tokenize :: [OptDescr a] -> (String -> a) -> ParserT [String] (WriterT String Id) [a]

module Data.Serialize
class Serializable t
encode :: Serializable t => t -> Builder
serializable :: Serializable t => Parser Bytes t

-- | <a>Builder</a>s denote sequences of bytes. They are <a>Monoid</a>s
--   where <a>mempty</a> is the zero-length sequence and <a>mappend</a> is
--   concatenation, which runs in <i>O(1)</i>.
data Builder :: *
bytesBuilder :: Bytes :<->: Builder
chunkBuilder :: Chunk :<->: Builder
serialize :: Serializable t => t -> Bytes
serial :: (Serializable t, Serializable t') => Traversal t t' Bytes Bytes

-- | Encode a single unsigned byte as-is.
word8 :: Word8 -> Builder

-- | 8-bit unsigned integer type
data Word8 :: *

-- | 32-bit unsigned integer type
data Word32 :: *

-- | 64-bit unsigned integer type
data Word64 :: *
data Either3 a b c
Alt3l'1 :: a -> Either3 a b c
Alt3l'2 :: b -> Either3 a b c
Alt3l'3 :: c -> Either3 a b c
instance Serializable a => Serializable (Range a)
instance (Serializable a, Serializable b, Serializable c) => Serializable (Either3 a b c)
instance (Serializable a, Serializable b) => Serializable (a :+: b)
instance (Serializable a, Serializable b, Serializable c, Serializable d, Serializable e) => Serializable (a, b, c, d, e)
instance (Serializable a, Serializable b, Serializable c, Serializable d) => Serializable (a, b, c, d)
instance (Serializable a, Serializable b, Serializable c) => Serializable (a, b, c)
instance (Serializable a, Serializable b) => Serializable (a :*: b)
instance (Ord a, Serializable a) => Serializable (Set a)
instance (Ord k, Ord a, Serializable k, Serializable a) => Serializable (Bimap k a)
instance (Ord k, Serializable k, Serializable a) => Serializable (Map k a)
instance Serializable a => Serializable [a]
instance Serializable a => Serializable (Maybe a)
instance Serializable Integer
instance Serializable Int
instance Serializable Word64
instance Serializable Word32
instance Serializable Word8
instance Serializable Char
instance Monoid Builder
instance Semigroup Builder
instance Monoid Word64
instance Semigroup Word64
instance Monoid Word32
instance Semigroup Word32
instance Monoid Word8
instance Semigroup Word8