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


-- | Lua parser and pretty-printer
--   
--   Lua 5.3 lexer, parser and pretty-printer.
@package language-lua
@version 0.9.0

module Language.Lua.StringLiteral
interpretStringLiteral :: String -> Maybe ByteString

-- | Convert a string literal body to string literal syntax
constructStringLiteral :: ByteString -> String

module Language.Lua.Token

-- | Lua tokens
data Token

-- | +
TokPlus :: Token

-- | -
TokMinus :: Token

-- | *
TokStar :: Token

-- | /
TokSlash :: Token

-- | %
TokPercent :: Token

-- | ^
TokExp :: Token

-- | #
TokSh :: Token

-- | ==
TokEqual :: Token

-- | ~=
TokNotequal :: Token

-- | <=
TokLEq :: Token

-- | >=
TokGEq :: Token

-- | <
TokLT :: Token

-- | >
TokGT :: Token

-- | =
TokAssign :: Token

-- | (
TokLParen :: Token

-- | )
TokRParen :: Token

-- | {
TokLBrace :: Token

-- | }
TokRBrace :: Token

-- | [
TokLBracket :: Token

-- | ]
TokRBracket :: Token

-- | ::
TokDColon :: Token

-- | ;
TokSemic :: Token

-- | :
TokColon :: Token

-- | ,
TokComma :: Token

-- | .
TokDot :: Token

-- | ..
TokDDot :: Token

-- | ...
TokEllipsis :: Token

-- | <<
TokDLT :: Token

-- | >>
TokDGT :: Token

-- | &
TokAmpersand :: Token

-- | |
TokPipe :: Token

-- | //
TokDSlash :: Token

-- | ~
TokTilde :: Token

-- | and
TokAnd :: Token

-- | break
TokBreak :: Token

-- | do
TokDo :: Token

-- | else
TokElse :: Token

-- | elseif
TokElseIf :: Token

-- | end
TokEnd :: Token

-- | false
TokFalse :: Token

-- | for
TokFor :: Token

-- | function
TokFunction :: Token

-- | goto
TokGoto :: Token

-- | if
TokIf :: Token

-- | in
TokIn :: Token

-- | local
TokLocal :: Token

-- | nil
TokNil :: Token

-- | not
TokNot :: Token

-- | or
TokOr :: Token

-- | repeat
TokRepeat :: Token

-- | return
TokReturn :: Token

-- | then
TokThen :: Token

-- | true
TokTrue :: Token

-- | until
TokUntil :: Token

-- | while
TokWhile :: Token

-- | number constant
TokNum :: Token

-- | string constant
TokSLit :: Token

-- | identifier
TokIdent :: Token

-- | white space
TokWhiteSpace :: Token

-- | comment
TokComment :: Token

-- | unterminated string
TokUntermString :: Token

-- | unterminated comment
TokUntermComment :: Token

-- | unexpected character
TokUnexpected :: Token
instance GHC.Classes.Eq Language.Lua.Token.Token
instance GHC.Show.Show Language.Lua.Token.Token

module Language.Lua.Annotated.Lexer

-- | Lua lexer with default <tt>=<a>string</a></tt> name.
llex :: Text -> [LexToken SourcePos]

-- | Lua lexer with explicit name.
llexNamed :: String -> Text -> [LexToken SourcePos]

-- | Lua lexer with explicit name, preseves white space and comments.
llexNamedWithWhiteSpace :: String -> Text -> [LexToken SourcePos]

-- | Run Lua lexer on a file.
llexFile :: FilePath -> IO [LexToken SourcePos]

-- | Lua token with position information.
data LexToken a
LexToken :: Token -> a -> Text -> LexToken a
[ltokToken] :: LexToken a -> Token
[ltokPos] :: LexToken a -> a
[ltokLexeme] :: LexToken a -> Text

-- | The type of locations in a source file
data SourcePos
SourcePos :: String -> {-# UNPACK #-} !Int -> SourcePos
[sourcePosName] :: SourcePos -> String
[sourcePosIndex, sourcePosLine, sourcePosColumn] :: SourcePos -> {-# UNPACK #-} !Int

-- | This function drops whitespace and comments from a list of lexemes in
--   order to make it suitable for parsing.
dropWhiteSpace :: [LexToken a] -> [LexToken a]
instance GHC.Base.Functor Language.Lua.Annotated.Lexer.AlexLastAcc


-- | Lua 5.3 syntax tree, as specified in
--   <a>http://www.lua.org/manual/5.3/manual.html#9</a>. Annotation
--   implementation is inspired by haskell-src-exts.
module Language.Lua.Annotated.Syntax
data Name a
Name :: a -> Text -> Name a
data Stat a

-- | var1, var2 .. = exp1, exp2 ..
Assign :: a -> [Var a] -> [Exp a] -> Stat a

-- | function call
FunCall :: a -> (FunCall a) -> Stat a

-- | label for goto
Label :: a -> (Name a) -> Stat a

-- | break
Break :: a -> Stat a

-- | goto label
Goto :: a -> (Name a) -> Stat a

-- | do .. end
Do :: a -> (Block a) -> Stat a

-- | while .. do .. end
While :: a -> (Exp a) -> (Block a) -> Stat a

-- | repeat .. until ..
Repeat :: a -> (Block a) -> (Exp a) -> Stat a

-- | if .. then .. [elseif ..] [else ..] end
If :: a -> [(Exp a, Block a)] -> (Maybe (Block a)) -> Stat a

-- | for x=start, end [, step] do .. end
ForRange :: a -> (Name a) -> (Exp a) -> (Exp a) -> (Maybe (Exp a)) -> (Block a) -> Stat a

-- | for x in .. do .. end
ForIn :: a -> [Name a] -> [Exp a] -> (Block a) -> Stat a

-- | function &lt;var&gt; (..) .. end
FunAssign :: a -> (FunName a) -> (FunBody a) -> Stat a

-- | local function &lt;var&gt; (..) .. end
LocalFunAssign :: a -> (Name a) -> (FunBody a) -> Stat a

-- | local var1, var2 .. = exp1, exp2 ..
LocalAssign :: a -> [Name a] -> (Maybe [Exp a]) -> Stat a

-- | <i>;</i>
EmptyStat :: a -> Stat a
data Exp a
Nil :: a -> Exp a
Bool :: a -> Bool -> Exp a
Number :: a -> Text -> Exp a
String :: a -> Text -> Exp a

-- | <i>...</i>
Vararg :: a -> Exp a

-- | <i>function (..) .. end</i>
EFunDef :: a -> (FunDef a) -> Exp a
PrefixExp :: a -> (PrefixExp a) -> Exp a

-- | table constructor
TableConst :: a -> (Table a) -> Exp a

-- | binary operators, <i>+ - * ^ % .. <a>&lt;=</a> &gt;= == ~= and or</i>
Binop :: a -> (Binop a) -> (Exp a) -> (Exp a) -> Exp a

-- | unary operators, <i>- not #</i>
Unop :: a -> (Unop a) -> (Exp a) -> Exp a
data Var a

-- | variable
VarName :: a -> (Name a) -> Var a

-- | <i>table[exp]</i>
Select :: a -> (PrefixExp a) -> (Exp a) -> Var a

-- | <i>table.variable</i>
SelectName :: a -> (PrefixExp a) -> (Name a) -> Var a
data Binop a
Add :: a -> Binop a
Sub :: a -> Binop a
Mul :: a -> Binop a
Div :: a -> Binop a
Exp :: a -> Binop a
Mod :: a -> Binop a
Concat :: a -> Binop a
LT :: a -> Binop a
LTE :: a -> Binop a
GT :: a -> Binop a
GTE :: a -> Binop a
EQ :: a -> Binop a
NEQ :: a -> Binop a
And :: a -> Binop a
Or :: a -> Binop a
IDiv :: a -> Binop a
ShiftL :: a -> Binop a
ShiftR :: a -> Binop a
BAnd :: a -> Binop a
BOr :: a -> Binop a
BXor :: a -> Binop a
data Unop a
Neg :: a -> Unop a
Not :: a -> Unop a
Len :: a -> Unop a
Complement :: a -> Unop a
data PrefixExp a
PEVar :: a -> (Var a) -> PrefixExp a
PEFunCall :: a -> (FunCall a) -> PrefixExp a
Paren :: a -> (Exp a) -> PrefixExp a
data Table a

-- | list of table fields
Table :: a -> [TableField a] -> Table a
data TableField a

-- | <i>[exp] = exp</i>
ExpField :: a -> (Exp a) -> (Exp a) -> TableField a

-- | <i>name = exp</i>
NamedField :: a -> (Name a) -> (Exp a) -> TableField a
Field :: a -> (Exp a) -> TableField a

-- | A block is list of statements with optional return statement.
data Block a
Block :: a -> [Stat a] -> (Maybe [Exp a]) -> Block a
data FunName a
FunName :: a -> (Name a) -> [Name a] -> (Maybe (Name a)) -> FunName a
data FunDef a
FunDef :: a -> (FunBody a) -> FunDef a
data FunBody a

-- | (args, vararg, block)
FunBody :: a -> [Name a] -> (Maybe a) -> (Block a) -> FunBody a
data FunCall a

-- | <i>prefixexp ( funarg )</i>
NormalFunCall :: a -> (PrefixExp a) -> (FunArg a) -> FunCall a

-- | <i>prefixexp : name ( funarg )</i>
MethodCall :: a -> (PrefixExp a) -> (Name a) -> (FunArg a) -> FunCall a
data FunArg a

-- | list of args
Args :: a -> [Exp a] -> FunArg a

-- | table constructor
TableArg :: a -> (Table a) -> FunArg a

-- | string
StringArg :: a -> Text -> FunArg a
class Functor ast => Annotated ast

-- | Retrieve the annotation of an AST node.
ann :: Annotated ast => ast l -> l

-- | Change the annotation of an AST node. Note that only the annotation of
--   the node itself is affected, and not the annotations of any child
--   nodes. if all nodes in the AST tree are to be affected, use
--   <a>fmap</a>.
amap :: Annotated ast => (l -> l) -> ast l -> ast l
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Var a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Var a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Var
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Var a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Var a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.PrefixExp a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.PrefixExp a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.PrefixExp
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.PrefixExp a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.PrefixExp a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.FunCall a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.FunCall a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.FunCall
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.FunCall a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.FunCall a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Stat a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Stat a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Stat
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Stat a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Stat a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Block a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Block a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Block
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Block a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Block a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.FunBody a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.FunBody a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.FunBody
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.FunBody a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.FunBody a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.FunDef a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.FunDef a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.FunDef
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.FunDef a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.FunDef a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Exp a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Exp a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Exp
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Exp a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Exp a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.TableField a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.TableField a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.TableField
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.TableField a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.TableField a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Table a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Table a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Table
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Table a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Table a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.FunArg a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.FunArg a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.FunArg
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.FunArg a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.FunArg a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.FunName a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.FunName a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.FunName
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.FunName a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.FunName a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Unop a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Unop a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Unop
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Unop a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Unop a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Binop a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Binop a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Binop
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Binop a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Binop a)
instance GHC.Generics.Generic (Language.Lua.Annotated.Syntax.Name a)
instance Data.Data.Data a => Data.Data.Data (Language.Lua.Annotated.Syntax.Name a)
instance GHC.Base.Functor Language.Lua.Annotated.Syntax.Name
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Lua.Annotated.Syntax.Name a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Lua.Annotated.Syntax.Name a)
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Stat
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Exp
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Var
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Binop
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Unop
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.PrefixExp
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Table
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.TableField
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Block
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.FunName
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.FunDef
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.FunBody
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.FunCall
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.FunArg
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.Annotated.Syntax.Name
instance Language.Lua.Annotated.Syntax.Annotated Language.Lua.LexerUtils.LexToken
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Name a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Stat a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Exp a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Var a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Binop a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Unop a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.PrefixExp a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Table a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.TableField a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.Block a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.FunName a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.FunDef a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.FunBody a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.FunCall a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Language.Lua.Annotated.Syntax.FunArg a)

module Language.Lua.Annotated.Parser

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parser a -> Text -> Either (SourcePos, String) a

-- | Runs Lua lexer before parsing. Use <tt>parseNamedText stat "name"</tt>
--   to parse statements, and <tt>parseText exp "name"</tt> to parse
--   expressions.
parseNamedText :: Parser a -> String -> Text -> Either (SourcePos, String) a

-- | Parse a Lua file. You can use <tt>parseText chunk</tt> to parse a file
--   from a string.
parseFile :: FilePath -> IO (Either (SourcePos, String) (Block SourcePos))
data Parser a
chunk :: Parser (Block SourcePos)
exp :: Parser (Exp SourcePos)
stat :: Parser (Stat SourcePos)
instance GHC.Base.Functor Language.Lua.Annotated.Parser.Parser

module Language.Lua.Annotated

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parser a -> Text -> Either (SourcePos, String) a

-- | Runs Lua lexer before parsing. Use <tt>parseNamedText stat "name"</tt>
--   to parse statements, and <tt>parseText exp "name"</tt> to parse
--   expressions.
parseNamedText :: Parser a -> String -> Text -> Either (SourcePos, String) a

-- | Parse a Lua file. You can use <tt>parseText chunk</tt> to parse a file
--   from a string.
parseFile :: FilePath -> IO (Either (SourcePos, String) (Block SourcePos))
stat :: Parser (Stat SourcePos)
exp :: Parser (Exp SourcePos)
chunk :: Parser (Block SourcePos)


-- | Lua 5.3 syntax tree, as specified in
--   <a>http://www.lua.org/manual/5.3/manual.html#9</a>.
module Language.Lua.Syntax
newtype Name
Name :: Text -> Name
data Stat

-- | var1, var2 .. = exp1, exp2 ..
Assign :: [Var] -> [Exp] -> Stat

-- | function call
FunCall :: FunCall -> Stat

-- | label for goto
Label :: Name -> Stat

-- | break
Break :: Stat

-- | goto label
Goto :: Name -> Stat

-- | do .. end
Do :: Block -> Stat

-- | while .. do .. end
While :: Exp -> Block -> Stat

-- | repeat .. until ..
Repeat :: Block -> Exp -> Stat

-- | if .. then .. [elseif ..] [else ..] end
If :: [(Exp, Block)] -> (Maybe Block) -> Stat

-- | for x=start, end [, step] do .. end
ForRange :: Name -> Exp -> Exp -> (Maybe Exp) -> Block -> Stat

-- | for x in .. do .. end
ForIn :: [Name] -> [Exp] -> Block -> Stat

-- | function &lt;var&gt; (..) .. end
FunAssign :: FunName -> FunBody -> Stat

-- | local function &lt;var&gt; (..) .. end
LocalFunAssign :: Name -> FunBody -> Stat

-- | local var1, var2 .. = exp1, exp2 ..
LocalAssign :: [Name] -> (Maybe [Exp]) -> Stat

-- | <i>;</i>
EmptyStat :: Stat
data Exp
Nil :: Exp
Bool :: Bool -> Exp
Number :: Text -> Exp
String :: Text -> Exp

-- | <i>...</i>
Vararg :: Exp

-- | <i>function (..) .. end</i>
EFunDef :: FunBody -> Exp
PrefixExp :: PrefixExp -> Exp

-- | table constructor
TableConst :: [TableField] -> Exp

-- | binary operators, <i>+ - * ^ % .. <a>&lt;=</a> &gt;= == ~= and or</i>
Binop :: Binop -> Exp -> Exp -> Exp

-- | unary operators, <i>- not #</i>
Unop :: Unop -> Exp -> Exp
data Var

-- | variable
VarName :: Name -> Var

-- | <i>table[exp]</i>
Select :: PrefixExp -> Exp -> Var

-- | <i>table.variable</i>
SelectName :: PrefixExp -> Name -> Var
data Binop
Add :: Binop
Sub :: Binop
Mul :: Binop
Div :: Binop
Exp :: Binop
Mod :: Binop
Concat :: Binop
LT :: Binop
LTE :: Binop
GT :: Binop
GTE :: Binop
EQ :: Binop
NEQ :: Binop
And :: Binop
Or :: Binop
IDiv :: Binop
ShiftL :: Binop
ShiftR :: Binop
BAnd :: Binop
BOr :: Binop
BXor :: Binop
data Unop
Neg :: Unop
Not :: Unop
Len :: Unop
Complement :: Unop
data PrefixExp
PEVar :: Var -> PrefixExp
PEFunCall :: FunCall -> PrefixExp
Paren :: Exp -> PrefixExp
data TableField

-- | <i>[exp] = exp</i>
ExpField :: Exp -> Exp -> TableField

-- | <i>name = exp</i>
NamedField :: Name -> Exp -> TableField
Field :: Exp -> TableField

-- | A block is list of statements with optional return statement.
data Block
Block :: [Stat] -> (Maybe [Exp]) -> Block
data FunName
FunName :: Name -> [Name] -> (Maybe Name) -> FunName
data FunBody

-- | (args, vararg, block)
FunBody :: [Name] -> Bool -> Block -> FunBody
data FunCall

-- | <i>prefixexp ( funarg )</i>
NormalFunCall :: PrefixExp -> FunArg -> FunCall

-- | <i>prefixexp : name ( funarg )</i>
MethodCall :: PrefixExp -> Name -> FunArg -> FunCall
data FunArg

-- | list of args
Args :: [Exp] -> FunArg

-- | table constructor
TableArg :: [TableField] -> FunArg

-- | string
StringArg :: Text -> FunArg
instance GHC.Generics.Generic Language.Lua.Syntax.Var
instance Data.Data.Data Language.Lua.Syntax.Var
instance GHC.Classes.Eq Language.Lua.Syntax.Var
instance GHC.Show.Show Language.Lua.Syntax.Var
instance GHC.Generics.Generic Language.Lua.Syntax.PrefixExp
instance Data.Data.Data Language.Lua.Syntax.PrefixExp
instance GHC.Classes.Eq Language.Lua.Syntax.PrefixExp
instance GHC.Show.Show Language.Lua.Syntax.PrefixExp
instance GHC.Generics.Generic Language.Lua.Syntax.FunCall
instance Data.Data.Data Language.Lua.Syntax.FunCall
instance GHC.Classes.Eq Language.Lua.Syntax.FunCall
instance GHC.Show.Show Language.Lua.Syntax.FunCall
instance GHC.Generics.Generic Language.Lua.Syntax.Stat
instance Data.Data.Data Language.Lua.Syntax.Stat
instance GHC.Classes.Eq Language.Lua.Syntax.Stat
instance GHC.Show.Show Language.Lua.Syntax.Stat
instance GHC.Generics.Generic Language.Lua.Syntax.Block
instance Data.Data.Data Language.Lua.Syntax.Block
instance GHC.Classes.Eq Language.Lua.Syntax.Block
instance GHC.Show.Show Language.Lua.Syntax.Block
instance GHC.Generics.Generic Language.Lua.Syntax.FunBody
instance Data.Data.Data Language.Lua.Syntax.FunBody
instance GHC.Classes.Eq Language.Lua.Syntax.FunBody
instance GHC.Show.Show Language.Lua.Syntax.FunBody
instance GHC.Generics.Generic Language.Lua.Syntax.Exp
instance Data.Data.Data Language.Lua.Syntax.Exp
instance GHC.Classes.Eq Language.Lua.Syntax.Exp
instance GHC.Show.Show Language.Lua.Syntax.Exp
instance GHC.Generics.Generic Language.Lua.Syntax.TableField
instance Data.Data.Data Language.Lua.Syntax.TableField
instance GHC.Classes.Eq Language.Lua.Syntax.TableField
instance GHC.Show.Show Language.Lua.Syntax.TableField
instance GHC.Generics.Generic Language.Lua.Syntax.FunArg
instance Data.Data.Data Language.Lua.Syntax.FunArg
instance GHC.Classes.Eq Language.Lua.Syntax.FunArg
instance GHC.Show.Show Language.Lua.Syntax.FunArg
instance GHC.Generics.Generic Language.Lua.Syntax.FunName
instance Data.Data.Data Language.Lua.Syntax.FunName
instance GHC.Classes.Eq Language.Lua.Syntax.FunName
instance GHC.Show.Show Language.Lua.Syntax.FunName
instance GHC.Generics.Generic Language.Lua.Syntax.Unop
instance Data.Data.Data Language.Lua.Syntax.Unop
instance GHC.Classes.Eq Language.Lua.Syntax.Unop
instance GHC.Show.Show Language.Lua.Syntax.Unop
instance GHC.Generics.Generic Language.Lua.Syntax.Binop
instance Data.Data.Data Language.Lua.Syntax.Binop
instance GHC.Classes.Eq Language.Lua.Syntax.Binop
instance GHC.Show.Show Language.Lua.Syntax.Binop
instance GHC.Generics.Generic Language.Lua.Syntax.Name
instance Data.Data.Data Language.Lua.Syntax.Name
instance GHC.Classes.Eq Language.Lua.Syntax.Name
instance GHC.Show.Show Language.Lua.Syntax.Name
instance Control.DeepSeq.NFData Language.Lua.Syntax.Name
instance Control.DeepSeq.NFData Language.Lua.Syntax.Stat
instance Control.DeepSeq.NFData Language.Lua.Syntax.Exp
instance Control.DeepSeq.NFData Language.Lua.Syntax.Var
instance Control.DeepSeq.NFData Language.Lua.Syntax.Binop
instance Control.DeepSeq.NFData Language.Lua.Syntax.Unop
instance Control.DeepSeq.NFData Language.Lua.Syntax.PrefixExp
instance Control.DeepSeq.NFData Language.Lua.Syntax.TableField
instance Control.DeepSeq.NFData Language.Lua.Syntax.Block
instance Control.DeepSeq.NFData Language.Lua.Syntax.FunName
instance Control.DeepSeq.NFData Language.Lua.Syntax.FunBody
instance Control.DeepSeq.NFData Language.Lua.Syntax.FunCall
instance Control.DeepSeq.NFData Language.Lua.Syntax.FunArg


-- | Lua pretty-printer.
module Language.Lua.PrettyPrinter
pprint :: LPretty a => a -> Doc

-- | This is the default pretty printer which is used by <a>show</a>,
--   <a>putDoc</a> and <a>hPutDoc</a>. <tt>(renderPretty ribbonfrac width
--   x)</tt> renders document <tt>x</tt> with a page width of
--   <tt>width</tt> and a ribbon width of <tt>(ribbonfrac * width)</tt>
--   characters. The ribbon width is the maximal amount of non-indentation
--   characters on a line. The parameter <tt>ribbonfrac</tt> should be
--   between <tt>0.0</tt> and <tt>1.0</tt>. If it is lower or higher, the
--   ribbon width will be 0 or <tt>width</tt> respectively.
renderPretty :: Float -> Int -> Doc -> SimpleDoc

-- | <tt>(displayS simpleDoc)</tt> takes the output <tt>simpleDoc</tt> from
--   a rendering function and transforms it to a <a>ShowS</a> type (for use
--   in the <a>Show</a> class).
--   
--   <pre>
--   showWidth :: Int -&gt; Doc -&gt; String
--   showWidth w x   = displayS (renderPretty 0.4 w x) ""
--   </pre>
displayS :: SimpleDoc -> ShowS

-- | <tt>(displayIO handle simpleDoc)</tt> writes <tt>simpleDoc</tt> to the
--   file handle <tt>handle</tt>. This function is used for example by
--   <a>hPutDoc</a>:
--   
--   <pre>
--   hPutDoc handle doc  = displayIO handle (renderPretty 0.4 100 doc)
--   </pre>
displayIO :: Handle -> SimpleDoc -> IO ()
class LPretty a where pprint = pprint' 0 pprint' _ = pprint
pprint :: LPretty a => a -> Doc
instance Language.Lua.PrettyPrinter.LPretty [GHC.Types.Char]
instance Language.Lua.PrettyPrinter.LPretty GHC.Types.Bool
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Exp
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Var
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Binop
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Unop
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.PrefixExp
instance Language.Lua.PrettyPrinter.LPretty [Language.Lua.Syntax.TableField]
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.TableField
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Block
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.FunName
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.FunBody
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.FunCall
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.FunArg
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Stat
instance Language.Lua.PrettyPrinter.LPretty Language.Lua.Syntax.Name


-- | Remove annotations.
module Language.Lua.Annotated.Simplify
sName :: Name a -> Name
sStat :: Stat a -> Stat
sExp :: Exp a -> Exp
sBlock :: Block a -> Block
sVar :: Var a -> Var
sFunCall :: FunCall a -> FunCall
sFunName :: FunName a -> FunName
sFunBody :: FunBody a -> FunBody
sFunDef :: FunDef a -> FunBody
sPrefixExp :: PrefixExp a -> PrefixExp
sTable :: Table a -> [TableField]
sBinop :: Binop a -> Binop
sUnop :: Unop a -> Unop
sFunArg :: FunArg a -> FunArg
sTableField :: TableField a -> TableField

module Language.Lua.Parser

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parser a -> Text -> Either (SourcePos, String) a

-- | Runs Lua lexer before parsing. Use <tt>parseNamedText stat "name"</tt>
--   to parse statements, and <tt>parseText exp "name"</tt> to parse
--   expressions.
parseNamedText :: Parser a -> String -> Text -> Either (SourcePos, String) a
parseFile :: FilePath -> IO (Either (SourcePos, String) Block)
stat :: Parser Stat
exp :: Parser Exp
chunk :: Parser Block

module Language.Lua

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parser a -> Text -> Either (SourcePos, String) a

-- | Runs Lua lexer before parsing. Use <tt>parseNamedText stat "name"</tt>
--   to parse statements, and <tt>parseText exp "name"</tt> to parse
--   expressions.
parseNamedText :: Parser a -> String -> Text -> Either (SourcePos, String) a
parseFile :: FilePath -> IO (Either (SourcePos, String) Block)
stat :: Parser Stat
exp :: Parser Exp
chunk :: Parser Block
pprint :: LPretty a => a -> Doc