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


-- | Syntax descriptions for unified parsing and pretty-printing.
--   
@package syntax
@version 0.3.0.0


-- | Combinators that work with any sequence type.
module Data.Syntax.Combinator

-- | One or zero occurences of <tt>f</tt>.
optional :: SemiIsoAlternative f => f a -> f (Maybe a)

-- | Like <a>optional</a>, but specialized for <tt>()</tt>.
opt :: SemiIsoAlternative f => f () -> f ()

-- | Parser one or zero occurences of <tt>f</tt>, but prints nothing.
opt_ :: SemiIsoAlternative f => f () -> f ()

-- | <tt>manyTill p end</tt> applies action p zero or more times until
--   action end succeeds, and returns the list of values returned by p.
manyTill :: SemiIsoAlternative f => f a -> f () -> f [a]

-- | Zero or more occurences of <tt>v</tt> separated by <tt>s</tt>.
sepBy :: SemiIsoAlternative f => f a -> f () -> f [a]

-- | One or more occurences of <tt>v</tt> separated by <tt>s</tt>.
sepBy1 :: SemiIsoAlternative f => f a -> f () -> f [a]

-- | Tries to apply the actions in the list in order, until one of them
--   succeeds. Returns the value of the succeeding action.
choice :: SemiIsoAlternative f => [f a] -> f a

-- | Combine two alternatives.
eitherOf :: SemiIsoAlternative f => f a -> f b -> f (Either a b)


-- | Abstract syntax descriptions based on semi-isomorphisms.
module Data.Syntax

-- | An abstract syntax description based on semi-isomorphisms.
--   
--   This class can be implemented by both parsers and printers (and maybe
--   more?).
--   
--   The usual use is to write a polymorphic syntax description and
--   instantiate it both as a parser and a printer. An example is available
--   in the 'syntax-example' package.
--   
--   Methods of this class try to mimic <a>Data.Attoparsec.Text</a>
--   interface.
class (SemiIsoAlternative syn, SemiIsoMonad syn, IsSequence seq, Eq seq, Eq (Element seq)) => Syntax syn seq | syn -> seq where char c = rev (exact c) /$/ anyChar notChar c = bifiltered (/= c) /$/ anyChar satisfy p = bifiltered p /$/ anyChar satisfyWith ai p = bifiltered p . ai /$/ anyChar string s = rev (exact s) /$/ take (olength s) take n = packed /$/ sireplicate n anyChar takeWhile p = packed /$/ simany (satisfy p) takeWhile1 p = packed /$/ sisome (satisfy p) takeTill p = takeWhile (not . p) takeTill1 p = takeWhile1 (not . p)
anyChar :: Syntax syn seq => syn (Element seq)
char :: Syntax syn seq => Element seq -> syn ()
notChar :: Syntax syn seq => Element seq -> syn (Element seq)
satisfy :: Syntax syn seq => (Element seq -> Bool) -> syn (Element seq)
satisfyWith :: Syntax syn seq => ASemiIso' a (Element seq) -> (a -> Bool) -> syn a
string :: Syntax syn seq => seq -> syn ()
take :: Syntax syn seq => Int -> syn seq
takeWhile :: Syntax syn seq => (Element seq -> Bool) -> syn seq
takeWhile1 :: Syntax syn seq => (Element seq -> Bool) -> syn seq
takeTill :: Syntax syn seq => (Element seq -> Bool) -> syn seq
takeTill1 :: Syntax syn seq => (Element seq -> Bool) -> syn seq

-- | An isomorphism between a sequence and a list of its elements.
packed :: IsSequence seq => Iso' seq [Element seq]


-- | Common combinators that work with sequences of chars.
module Data.Syntax.Char

-- | Syntax constrainted to sequences of chars.
--   
--   Note: methods of this class do not have default implementations (for
--   now), because their code is quite ugly and already written in most
--   parser libraries.
class (Syntax syn seq, Element seq ~ Char) => SyntaxChar syn seq
decimal :: (SyntaxChar syn seq, Integral a) => syn a
hexadecimal :: (SyntaxChar syn seq, Integral a, Bits a) => syn a
realFloat :: (SyntaxChar syn seq, RealFloat a) => syn a
scientific :: SyntaxChar syn seq => syn Scientific

-- | An useful synonym for SyntaxChars with Text sequences.
type SyntaxText syn = SyntaxChar syn Text

-- | A number with an optional leading <a>+</a> or <a>-</a> sign character.
signed :: (Real a, SyntaxChar syn seq) => syn a -> syn a

-- | Accepts zero or more spaces. Generates a single space.
spaces :: SyntaxChar syn seq => syn ()

-- | Accepts zero or more spaces. Generates no output.
spaces_ :: SyntaxChar syn seq => syn ()

-- | Accepts one or more spaces. Generates a single space.
spaces1 :: SyntaxChar syn seq => syn ()

-- | Accepts a single newline. Generates a newline.
endOfLine :: SyntaxChar syn seq => syn ()

-- | A decimal digit.
digitDec :: SyntaxChar syn seq => syn Int

-- | An octal digit.
digitOct :: SyntaxChar syn seq => syn Int

-- | A hex digit.
digitHex :: SyntaxChar syn seq => syn Int


-- | Provides a very simple indentation as a "monad" transformer.
module Data.Syntax.Indent

-- | Adds indentation to a syntax description.
data Indent m a

-- | <tt>runIndent m tab</tt> runs the <a>Indent</a> transformer using
--   <tt>tab</tt> once for each level of indentation.
runIndent :: Indent m a -> m () -> m a

-- | Inserts a new line and correct indentation, but does not require any
--   formatting when parsing (it just skips all white space).
breakLine :: SyntaxChar syn seq => Indent syn ()

-- | Increases the indentation level of its argument by one.
indented :: Indent m a -> Indent m a
instance SyntaxChar syn seq => SyntaxChar (Indent syn) seq
instance Syntax syn seq => Syntax (Indent syn) seq
instance SemiIsoFix m => SemiIsoFix (Indent m)
instance SemiIsoMonad m => SemiIsoMonad (Indent m)
instance SemiIsoAlternative m => SemiIsoAlternative (Indent m)
instance SemiIsoApply m => SemiIsoApply (Indent m)
instance SemiIsoFunctor m => SemiIsoFunctor (Indent m)