language-lua2-0.1.0.5: Lua parser and pretty printer

Safe HaskellSafe
LanguageHaskell2010

Language.Lua.Syntax

Contents

Description

Abstract syntax of Lua 5.3 source files. See http://www.lua.org/manual/5.3/ for more information.

Synopsis

AST nodes

data Ident a #

An identifier, defined as any string of letters, digits, or underscores, not beginning with a digit.

http://www.lua.org/manual/5.3/manual.html#3.1

Constructors

Ident !a !String 

Instances

Functor Ident # 

Methods

fmap :: (a -> b) -> Ident a -> Ident b #

(<$) :: a -> Ident b -> Ident a #

Annotated Ident # 

Methods

ann :: Functor f => (a -> f a) -> Ident a -> f (Ident a) #

Eq a => Eq (Ident a) # 

Methods

(==) :: Ident a -> Ident a -> Bool #

(/=) :: Ident a -> Ident a -> Bool #

Data a => Data (Ident a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ident a -> c (Ident a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ident a) #

toConstr :: Ident a -> Constr #

dataTypeOf :: Ident a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ident a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ident a)) #

gmapT :: (forall b. Data b => b -> b) -> Ident a -> Ident a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ident a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ident a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ident a -> m (Ident a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident a -> m (Ident a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident a -> m (Ident a) #

Show a => Show (Ident a) # 

Methods

showsPrec :: Int -> Ident a -> ShowS #

show :: Ident a -> String #

showList :: [Ident a] -> ShowS #

Generic (Ident a) # 

Associated Types

type Rep (Ident a) :: * -> * #

Methods

from :: Ident a -> Rep (Ident a) x #

to :: Rep (Ident a) x -> Ident a #

Pretty (Ident a) # 

Methods

pretty :: Ident a -> Doc #

prettyList :: [Ident a] -> Doc #

type Rep (Ident a) # 
type Rep (Ident a) = D1 (MetaData "Ident" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "Ident" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 String))))

data IdentList a #

Zero or more Idents.

Constructors

IdentList !a ![Ident a] 

Instances

Functor IdentList # 

Methods

fmap :: (a -> b) -> IdentList a -> IdentList b #

(<$) :: a -> IdentList b -> IdentList a #

Annotated IdentList # 

Methods

ann :: Functor f => (a -> f a) -> IdentList a -> f (IdentList a) #

Eq a => Eq (IdentList a) # 

Methods

(==) :: IdentList a -> IdentList a -> Bool #

(/=) :: IdentList a -> IdentList a -> Bool #

Data a => Data (IdentList a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdentList a -> c (IdentList a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IdentList a) #

toConstr :: IdentList a -> Constr #

dataTypeOf :: IdentList a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IdentList a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IdentList a)) #

gmapT :: (forall b. Data b => b -> b) -> IdentList a -> IdentList a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdentList a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdentList a -> r #

gmapQ :: (forall d. Data d => d -> u) -> IdentList a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentList a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdentList a -> m (IdentList a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentList a -> m (IdentList a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentList a -> m (IdentList a) #

Show a => Show (IdentList a) # 
Generic (IdentList a) # 

Associated Types

type Rep (IdentList a) :: * -> * #

Methods

from :: IdentList a -> Rep (IdentList a) x #

to :: Rep (IdentList a) x -> IdentList a #

type Rep (IdentList a) # 
type Rep (IdentList a) = D1 (MetaData "IdentList" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "IdentList" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 [Ident a]))))

data IdentList1 a #

One or more Idents.

Constructors

IdentList1 !a !(NonEmpty (Ident a)) 

Instances

Functor IdentList1 # 

Methods

fmap :: (a -> b) -> IdentList1 a -> IdentList1 b #

(<$) :: a -> IdentList1 b -> IdentList1 a #

Annotated IdentList1 # 

Methods

ann :: Functor f => (a -> f a) -> IdentList1 a -> f (IdentList1 a) #

Eq a => Eq (IdentList1 a) # 

Methods

(==) :: IdentList1 a -> IdentList1 a -> Bool #

(/=) :: IdentList1 a -> IdentList1 a -> Bool #

Data a => Data (IdentList1 a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdentList1 a -> c (IdentList1 a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IdentList1 a) #

toConstr :: IdentList1 a -> Constr #

dataTypeOf :: IdentList1 a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IdentList1 a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IdentList1 a)) #

gmapT :: (forall b. Data b => b -> b) -> IdentList1 a -> IdentList1 a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdentList1 a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdentList1 a -> r #

gmapQ :: (forall d. Data d => d -> u) -> IdentList1 a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentList1 a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdentList1 a -> m (IdentList1 a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentList1 a -> m (IdentList1 a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentList1 a -> m (IdentList1 a) #

Show a => Show (IdentList1 a) # 
Generic (IdentList1 a) # 

Associated Types

type Rep (IdentList1 a) :: * -> * #

Methods

from :: IdentList1 a -> Rep (IdentList1 a) x #

to :: Rep (IdentList1 a) x -> IdentList1 a #

type Rep (IdentList1 a) # 
type Rep (IdentList1 a) = D1 (MetaData "IdentList1" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "IdentList1" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (NonEmpty (Ident a))))))

type Chunk = Block #

A chunk; Lua's compilation unit.

http://www.lua.org/manual/5.3/manual.html#3.3.2

data Block a #

A block of statements, possibly ending in a return statement.

http://www.lua.org/manual/5.3/manual.html#3.3.1

Constructors

Block !a ![Statement a] !(Maybe (ReturnStatement a)) 

Instances

Functor Block # 

Methods

fmap :: (a -> b) -> Block a -> Block b #

(<$) :: a -> Block b -> Block a #

Annotated Block # 

Methods

ann :: Functor f => (a -> f a) -> Block a -> f (Block a) #

Eq a => Eq (Block a) # 

Methods

(==) :: Block a -> Block a -> Bool #

(/=) :: Block a -> Block a -> Bool #

Data a => Data (Block a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Block a -> c (Block a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Block a) #

toConstr :: Block a -> Constr #

dataTypeOf :: Block a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Block a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block a)) #

gmapT :: (forall b. Data b => b -> b) -> Block a -> Block a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Block a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Block a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Block a -> m (Block a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Block a -> m (Block a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Block a -> m (Block a) #

Show a => Show (Block a) # 

Methods

showsPrec :: Int -> Block a -> ShowS #

show :: Block a -> String #

showList :: [Block a] -> ShowS #

Generic (Block a) # 

Associated Types

type Rep (Block a) :: * -> * #

Methods

from :: Block a -> Rep (Block a) x #

to :: Rep (Block a) x -> Block a #

Pretty (Block a) # 

Methods

pretty :: Block a -> Doc #

prettyList :: [Block a] -> Doc #

type Rep (Block a) # 

data Statement a #

Constructors

EmptyStmt !a
;
Assign !a !(VariableList1 a) !(ExpressionList1 a)
var1, var2, var3 = exp1, exp2, exp3
FunCall !a !(FunctionCall a)
foo.bar(args)
Label !a !(Ident a)
::label::
Break !a
break
Goto !a !(Ident a)
goto label
Do !a !(Block a)
do block end
While !a !(Expression a) !(Block a)
while exp do block end
Repeat !a !(Block a) !(Expression a)
repeat block until exp
If !a !(NonEmpty (Expression a, Block a)) !(Maybe (Block a))
if exp then block else block end
For !a !(Ident a) !(Expression a) !(Expression a) !(Maybe (Expression a)) !(Block a)
for x = exp do block end
ForIn !a !(IdentList1 a) !(ExpressionList1 a) !(Block a)
for a, b, c in exp1, exp2, exp3 do block end
FunAssign !a !(FunctionName a) !(FunctionBody a)
function name body
LocalFunAssign !a !(Ident a) !(FunctionBody a)
local function name body
LocalAssign !a !(IdentList1 a) !(ExpressionList a)
local x, y, z

Instances

Functor Statement # 

Methods

fmap :: (a -> b) -> Statement a -> Statement b #

(<$) :: a -> Statement b -> Statement a #

Annotated Statement # 

Methods

ann :: Functor f => (a -> f a) -> Statement a -> f (Statement a) #

Eq a => Eq (Statement a) # 

Methods

(==) :: Statement a -> Statement a -> Bool #

(/=) :: Statement a -> Statement a -> Bool #

Data a => Data (Statement a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Statement a -> c (Statement a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Statement a) #

toConstr :: Statement a -> Constr #

dataTypeOf :: Statement a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Statement a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Statement a)) #

gmapT :: (forall b. Data b => b -> b) -> Statement a -> Statement a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Statement a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Statement a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Statement a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Statement a -> m (Statement a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement a -> m (Statement a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement a -> m (Statement a) #

Show a => Show (Statement a) # 
Generic (Statement a) # 

Associated Types

type Rep (Statement a) :: * -> * #

Methods

from :: Statement a -> Rep (Statement a) x #

to :: Rep (Statement a) x -> Statement a #

Pretty (Statement a) # 

Methods

pretty :: Statement a -> Doc #

prettyList :: [Statement a] -> Doc #

type Rep (Statement a) # 
type Rep (Statement a) = D1 (MetaData "Statement" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "EmptyStmt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "Assign" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (VariableList1 a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (ExpressionList1 a)))))) (C1 (MetaCons "FunCall" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FunctionCall a))))))) ((:+:) ((:+:) (C1 (MetaCons "Label" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Ident a))))) (C1 (MetaCons "Break" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) ((:+:) (C1 (MetaCons "Goto" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Ident a))))) (C1 (MetaCons "Do" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Block a)))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "While" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Block a)))))) (C1 (MetaCons "Repeat" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Block a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))))))) ((:+:) (C1 (MetaCons "If" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (NonEmpty (Expression a, Block a)))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Block a))))))) (C1 (MetaCons "For" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Ident a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Expression a)))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Block a))))))))) ((:+:) ((:+:) (C1 (MetaCons "ForIn" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (IdentList1 a)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (ExpressionList1 a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Block a)))))) (C1 (MetaCons "FunAssign" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FunctionName a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FunctionBody a))))))) ((:+:) (C1 (MetaCons "LocalFunAssign" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Ident a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FunctionBody a)))))) (C1 (MetaCons "LocalAssign" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (IdentList1 a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (ExpressionList a))))))))))

data ReturnStatement a #

Constructors

ReturnStatement !a !(ExpressionList a)
return exp1, exp2

Instances

Functor ReturnStatement # 

Methods

fmap :: (a -> b) -> ReturnStatement a -> ReturnStatement b #

(<$) :: a -> ReturnStatement b -> ReturnStatement a #

Annotated ReturnStatement # 

Methods

ann :: Functor f => (a -> f a) -> ReturnStatement a -> f (ReturnStatement a) #

Eq a => Eq (ReturnStatement a) # 
Data a => Data (ReturnStatement a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ReturnStatement a -> c (ReturnStatement a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ReturnStatement a) #

toConstr :: ReturnStatement a -> Constr #

dataTypeOf :: ReturnStatement a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ReturnStatement a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ReturnStatement a)) #

gmapT :: (forall b. Data b => b -> b) -> ReturnStatement a -> ReturnStatement a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ReturnStatement a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ReturnStatement a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ReturnStatement a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ReturnStatement a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ReturnStatement a -> m (ReturnStatement a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ReturnStatement a -> m (ReturnStatement a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ReturnStatement a -> m (ReturnStatement a) #

Show a => Show (ReturnStatement a) # 
Generic (ReturnStatement a) # 

Associated Types

type Rep (ReturnStatement a) :: * -> * #

Pretty (ReturnStatement a) # 
type Rep (ReturnStatement a) # 
type Rep (ReturnStatement a) = D1 (MetaData "ReturnStatement" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "ReturnStatement" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (ExpressionList a)))))

data FunctionName a #

Constructors

FunctionName !a !(IdentList1 a) !(Maybe (Ident a))
foo.bar:baz

Instances

Functor FunctionName # 

Methods

fmap :: (a -> b) -> FunctionName a -> FunctionName b #

(<$) :: a -> FunctionName b -> FunctionName a #

Annotated FunctionName # 

Methods

ann :: Functor f => (a -> f a) -> FunctionName a -> f (FunctionName a) #

Eq a => Eq (FunctionName a) # 
Data a => Data (FunctionName a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionName a -> c (FunctionName a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunctionName a) #

toConstr :: FunctionName a -> Constr #

dataTypeOf :: FunctionName a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunctionName a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunctionName a)) #

gmapT :: (forall b. Data b => b -> b) -> FunctionName a -> FunctionName a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionName a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionName a -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionName a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionName a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionName a -> m (FunctionName a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionName a -> m (FunctionName a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionName a -> m (FunctionName a) #

Show a => Show (FunctionName a) # 
Generic (FunctionName a) # 

Associated Types

type Rep (FunctionName a) :: * -> * #

Methods

from :: FunctionName a -> Rep (FunctionName a) x #

to :: Rep (FunctionName a) x -> FunctionName a #

Pretty (FunctionName a) # 
type Rep (FunctionName a) # 

data Variable a #

Constructors

VarIdent !a !(Ident a)
x
VarField !a !(PrefixExpression a) !(Expression a)
table[exp]
VarFieldName !a !(PrefixExpression a) !(Ident a)
table.field

Instances

Functor Variable # 

Methods

fmap :: (a -> b) -> Variable a -> Variable b #

(<$) :: a -> Variable b -> Variable a #

Annotated Variable # 

Methods

ann :: Functor f => (a -> f a) -> Variable a -> f (Variable a) #

Eq a => Eq (Variable a) # 

Methods

(==) :: Variable a -> Variable a -> Bool #

(/=) :: Variable a -> Variable a -> Bool #

Data a => Data (Variable a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Variable a -> c (Variable a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Variable a) #

toConstr :: Variable a -> Constr #

dataTypeOf :: Variable a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Variable a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Variable a)) #

gmapT :: (forall b. Data b => b -> b) -> Variable a -> Variable a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Variable a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Variable a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Variable a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Variable a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Variable a -> m (Variable a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Variable a -> m (Variable a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Variable a -> m (Variable a) #

Show a => Show (Variable a) # 

Methods

showsPrec :: Int -> Variable a -> ShowS #

show :: Variable a -> String #

showList :: [Variable a] -> ShowS #

Generic (Variable a) # 

Associated Types

type Rep (Variable a) :: * -> * #

Methods

from :: Variable a -> Rep (Variable a) x #

to :: Rep (Variable a) x -> Variable a #

Pretty (Variable a) # 

Methods

pretty :: Variable a -> Doc #

prettyList :: [Variable a] -> Doc #

type Rep (Variable a) # 

data VariableList1 a #

One or more Variables.

Constructors

VariableList1 !a !(NonEmpty (Variable a)) 

Instances

Functor VariableList1 # 

Methods

fmap :: (a -> b) -> VariableList1 a -> VariableList1 b #

(<$) :: a -> VariableList1 b -> VariableList1 a #

Annotated VariableList1 # 

Methods

ann :: Functor f => (a -> f a) -> VariableList1 a -> f (VariableList1 a) #

Eq a => Eq (VariableList1 a) # 
Data a => Data (VariableList1 a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VariableList1 a -> c (VariableList1 a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VariableList1 a) #

toConstr :: VariableList1 a -> Constr #

dataTypeOf :: VariableList1 a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (VariableList1 a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VariableList1 a)) #

gmapT :: (forall b. Data b => b -> b) -> VariableList1 a -> VariableList1 a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VariableList1 a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VariableList1 a -> r #

gmapQ :: (forall d. Data d => d -> u) -> VariableList1 a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VariableList1 a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VariableList1 a -> m (VariableList1 a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VariableList1 a -> m (VariableList1 a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VariableList1 a -> m (VariableList1 a) #

Show a => Show (VariableList1 a) # 
Generic (VariableList1 a) # 

Associated Types

type Rep (VariableList1 a) :: * -> * #

type Rep (VariableList1 a) # 
type Rep (VariableList1 a) = D1 (MetaData "VariableList1" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "VariableList1" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (NonEmpty (Variable a))))))

data Expression a #

Constructors

Nil !a 
Bool !a !Bool 
Integer !a !String 
Float !a !String 
String !a !String 
Vararg !a 
FunDef !a !(FunctionBody a) 
PrefixExp !a !(PrefixExpression a) 
TableCtor !a !(TableConstructor a) 
Binop !a !(Binop a) !(Expression a) !(Expression a) 
Unop !a !(Unop a) !(Expression a) 

Instances

Functor Expression # 

Methods

fmap :: (a -> b) -> Expression a -> Expression b #

(<$) :: a -> Expression b -> Expression a #

Annotated Expression # 

Methods

ann :: Functor f => (a -> f a) -> Expression a -> f (Expression a) #

Eq a => Eq (Expression a) # 

Methods

(==) :: Expression a -> Expression a -> Bool #

(/=) :: Expression a -> Expression a -> Bool #

Data a => Data (Expression a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Expression a -> c (Expression a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Expression a) #

toConstr :: Expression a -> Constr #

dataTypeOf :: Expression a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Expression a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expression a)) #

gmapT :: (forall b. Data b => b -> b) -> Expression a -> Expression a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expression a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expression a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Expression a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Expression a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expression a -> m (Expression a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression a -> m (Expression a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression a -> m (Expression a) #

Show a => Show (Expression a) # 
Generic (Expression a) # 

Associated Types

type Rep (Expression a) :: * -> * #

Methods

from :: Expression a -> Rep (Expression a) x #

to :: Rep (Expression a) x -> Expression a #

Pretty (Expression a) # 

Methods

pretty :: Expression a -> Doc #

prettyList :: [Expression a] -> Doc #

type Rep (Expression a) # 
type Rep (Expression a) = D1 (MetaData "Expression" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Nil" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Bool" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Bool))))) ((:+:) (C1 (MetaCons "Integer" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 String)))) ((:+:) (C1 (MetaCons "Float" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 String)))) (C1 (MetaCons "String" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 String))))))) ((:+:) ((:+:) (C1 (MetaCons "Vararg" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "FunDef" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FunctionBody a))))) (C1 (MetaCons "PrefixExp" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (PrefixExpression a))))))) ((:+:) (C1 (MetaCons "TableCtor" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (TableConstructor a))))) ((:+:) (C1 (MetaCons "Binop" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Binop a)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a)))))) (C1 (MetaCons "Unop" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Unop a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Expression a))))))))))

data ExpressionList a #

Zero or more Expressions.

Constructors

ExpressionList !a ![Expression a] 

Instances

Functor ExpressionList # 

Methods

fmap :: (a -> b) -> ExpressionList a -> ExpressionList b #

(<$) :: a -> ExpressionList b -> ExpressionList a #

Annotated ExpressionList # 

Methods

ann :: Functor f => (a -> f a) -> ExpressionList a -> f (ExpressionList a) #

Eq a => Eq (ExpressionList a) # 
Data a => Data (ExpressionList a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExpressionList a -> c (ExpressionList a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExpressionList a) #

toConstr :: ExpressionList a -> Constr #

dataTypeOf :: ExpressionList a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ExpressionList a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExpressionList a)) #

gmapT :: (forall b. Data b => b -> b) -> ExpressionList a -> ExpressionList a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpressionList a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpressionList a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExpressionList a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExpressionList a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExpressionList a -> m (ExpressionList a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpressionList a -> m (ExpressionList a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpressionList a -> m (ExpressionList a) #

Show a => Show (ExpressionList a) # 
Generic (ExpressionList a) # 

Associated Types

type Rep (ExpressionList a) :: * -> * #

type Rep (ExpressionList a) # 
type Rep (ExpressionList a) = D1 (MetaData "ExpressionList" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "ExpressionList" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 [Expression a]))))

data ExpressionList1 a #

One or more Expressions.

Constructors

ExpressionList1 !a !(NonEmpty (Expression a)) 

Instances

Functor ExpressionList1 # 

Methods

fmap :: (a -> b) -> ExpressionList1 a -> ExpressionList1 b #

(<$) :: a -> ExpressionList1 b -> ExpressionList1 a #

Annotated ExpressionList1 # 

Methods

ann :: Functor f => (a -> f a) -> ExpressionList1 a -> f (ExpressionList1 a) #

Eq a => Eq (ExpressionList1 a) # 
Data a => Data (ExpressionList1 a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExpressionList1 a -> c (ExpressionList1 a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExpressionList1 a) #

toConstr :: ExpressionList1 a -> Constr #

dataTypeOf :: ExpressionList1 a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ExpressionList1 a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExpressionList1 a)) #

gmapT :: (forall b. Data b => b -> b) -> ExpressionList1 a -> ExpressionList1 a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpressionList1 a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpressionList1 a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExpressionList1 a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExpressionList1 a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExpressionList1 a -> m (ExpressionList1 a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpressionList1 a -> m (ExpressionList1 a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpressionList1 a -> m (ExpressionList1 a) #

Show a => Show (ExpressionList1 a) # 
Generic (ExpressionList1 a) # 

Associated Types

type Rep (ExpressionList1 a) :: * -> * #

type Rep (ExpressionList1 a) # 
type Rep (ExpressionList1 a) = D1 (MetaData "ExpressionList1" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "ExpressionList1" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (NonEmpty (Expression a))))))

data PrefixExpression a #

Constructors

PrefixVar !a !(Variable a) 
PrefixFunCall !a !(FunctionCall a) 
Parens !a !(Expression a) 

Instances

Functor PrefixExpression # 

Methods

fmap :: (a -> b) -> PrefixExpression a -> PrefixExpression b #

(<$) :: a -> PrefixExpression b -> PrefixExpression a #

Annotated PrefixExpression # 

Methods

ann :: Functor f => (a -> f a) -> PrefixExpression a -> f (PrefixExpression a) #

Eq a => Eq (PrefixExpression a) # 
Data a => Data (PrefixExpression a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrefixExpression a -> c (PrefixExpression a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PrefixExpression a) #

toConstr :: PrefixExpression a -> Constr #

dataTypeOf :: PrefixExpression a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (PrefixExpression a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PrefixExpression a)) #

gmapT :: (forall b. Data b => b -> b) -> PrefixExpression a -> PrefixExpression a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrefixExpression a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrefixExpression a -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrefixExpression a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrefixExpression a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrefixExpression a -> m (PrefixExpression a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrefixExpression a -> m (PrefixExpression a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrefixExpression a -> m (PrefixExpression a) #

Show a => Show (PrefixExpression a) # 
Generic (PrefixExpression a) # 

Associated Types

type Rep (PrefixExpression a) :: * -> * #

Pretty (PrefixExpression a) # 
type Rep (PrefixExpression a) # 

data FunctionCall a #

Instances

Functor FunctionCall # 

Methods

fmap :: (a -> b) -> FunctionCall a -> FunctionCall b #

(<$) :: a -> FunctionCall b -> FunctionCall a #

Annotated FunctionCall # 

Methods

ann :: Functor f => (a -> f a) -> FunctionCall a -> f (FunctionCall a) #

Eq a => Eq (FunctionCall a) # 
Data a => Data (FunctionCall a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionCall a -> c (FunctionCall a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunctionCall a) #

toConstr :: FunctionCall a -> Constr #

dataTypeOf :: FunctionCall a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunctionCall a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunctionCall a)) #

gmapT :: (forall b. Data b => b -> b) -> FunctionCall a -> FunctionCall a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionCall a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionCall a -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionCall a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionCall a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionCall a -> m (FunctionCall a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionCall a -> m (FunctionCall a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionCall a -> m (FunctionCall a) #

Show a => Show (FunctionCall a) # 
Generic (FunctionCall a) # 

Associated Types

type Rep (FunctionCall a) :: * -> * #

Methods

from :: FunctionCall a -> Rep (FunctionCall a) x #

to :: Rep (FunctionCall a) x -> FunctionCall a #

Pretty (FunctionCall a) # 
type Rep (FunctionCall a) # 

data FunctionArgs a #

Constructors

Args !a !(ExpressionList a)
(exp1, exp2)
ArgsTable !a !(TableConstructor a)
{ x = exp }
ArgsString !a !String
"str"

Instances

Functor FunctionArgs # 

Methods

fmap :: (a -> b) -> FunctionArgs a -> FunctionArgs b #

(<$) :: a -> FunctionArgs b -> FunctionArgs a #

Annotated FunctionArgs # 

Methods

ann :: Functor f => (a -> f a) -> FunctionArgs a -> f (FunctionArgs a) #

Eq a => Eq (FunctionArgs a) # 
Data a => Data (FunctionArgs a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionArgs a -> c (FunctionArgs a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunctionArgs a) #

toConstr :: FunctionArgs a -> Constr #

dataTypeOf :: FunctionArgs a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunctionArgs a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunctionArgs a)) #

gmapT :: (forall b. Data b => b -> b) -> FunctionArgs a -> FunctionArgs a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionArgs a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionArgs a -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionArgs a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionArgs a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionArgs a -> m (FunctionArgs a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionArgs a -> m (FunctionArgs a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionArgs a -> m (FunctionArgs a) #

Show a => Show (FunctionArgs a) # 
Generic (FunctionArgs a) # 

Associated Types

type Rep (FunctionArgs a) :: * -> * #

Methods

from :: FunctionArgs a -> Rep (FunctionArgs a) x #

to :: Rep (FunctionArgs a) x -> FunctionArgs a #

Pretty (FunctionArgs a) # 
type Rep (FunctionArgs a) # 

data FunctionBody a #

Constructors

FunctionBody !a !(IdentList a) !Bool !(Block a)
(x, y, ...) block end

Instances

Functor FunctionBody # 

Methods

fmap :: (a -> b) -> FunctionBody a -> FunctionBody b #

(<$) :: a -> FunctionBody b -> FunctionBody a #

Annotated FunctionBody # 

Methods

ann :: Functor f => (a -> f a) -> FunctionBody a -> f (FunctionBody a) #

Eq a => Eq (FunctionBody a) # 
Data a => Data (FunctionBody a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionBody a -> c (FunctionBody a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunctionBody a) #

toConstr :: FunctionBody a -> Constr #

dataTypeOf :: FunctionBody a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunctionBody a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunctionBody a)) #

gmapT :: (forall b. Data b => b -> b) -> FunctionBody a -> FunctionBody a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionBody a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionBody a -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionBody a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionBody a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionBody a -> m (FunctionBody a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionBody a -> m (FunctionBody a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionBody a -> m (FunctionBody a) #

Show a => Show (FunctionBody a) # 
Generic (FunctionBody a) # 

Associated Types

type Rep (FunctionBody a) :: * -> * #

Methods

from :: FunctionBody a -> Rep (FunctionBody a) x #

to :: Rep (FunctionBody a) x -> FunctionBody a #

Pretty (FunctionBody a) # 
type Rep (FunctionBody a) # 

data TableConstructor a #

Constructors

TableConstructor !a !(FieldList a)
{ x = 5, [f(1)] = 6, 7 }

Instances

Functor TableConstructor # 

Methods

fmap :: (a -> b) -> TableConstructor a -> TableConstructor b #

(<$) :: a -> TableConstructor b -> TableConstructor a #

Annotated TableConstructor # 

Methods

ann :: Functor f => (a -> f a) -> TableConstructor a -> f (TableConstructor a) #

Eq a => Eq (TableConstructor a) # 
Data a => Data (TableConstructor a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableConstructor a -> c (TableConstructor a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TableConstructor a) #

toConstr :: TableConstructor a -> Constr #

dataTypeOf :: TableConstructor a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TableConstructor a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TableConstructor a)) #

gmapT :: (forall b. Data b => b -> b) -> TableConstructor a -> TableConstructor a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableConstructor a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableConstructor a -> r #

gmapQ :: (forall d. Data d => d -> u) -> TableConstructor a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TableConstructor a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableConstructor a -> m (TableConstructor a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableConstructor a -> m (TableConstructor a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableConstructor a -> m (TableConstructor a) #

Show a => Show (TableConstructor a) # 
Generic (TableConstructor a) # 

Associated Types

type Rep (TableConstructor a) :: * -> * #

Pretty (TableConstructor a) # 
type Rep (TableConstructor a) # 
type Rep (TableConstructor a) = D1 (MetaData "TableConstructor" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "TableConstructor" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (FieldList a)))))

data Field a #

Constructors

FieldExp !a !(Expression a) !(Expression a)
[exp1] = exp2
FieldIdent !a !(Ident a) !(Expression a)
name = exp
Field !a !(Expression a)
exp

Instances

Functor Field # 

Methods

fmap :: (a -> b) -> Field a -> Field b #

(<$) :: a -> Field b -> Field a #

Annotated Field # 

Methods

ann :: Functor f => (a -> f a) -> Field a -> f (Field a) #

Eq a => Eq (Field a) # 

Methods

(==) :: Field a -> Field a -> Bool #

(/=) :: Field a -> Field a -> Bool #

Data a => Data (Field a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Field a -> c (Field a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Field a) #

toConstr :: Field a -> Constr #

dataTypeOf :: Field a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Field a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Field a)) #

gmapT :: (forall b. Data b => b -> b) -> Field a -> Field a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Field a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Field a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Field a -> m (Field a) #

Show a => Show (Field a) # 

Methods

showsPrec :: Int -> Field a -> ShowS #

show :: Field a -> String #

showList :: [Field a] -> ShowS #

Generic (Field a) # 

Associated Types

type Rep (Field a) :: * -> * #

Methods

from :: Field a -> Rep (Field a) x #

to :: Rep (Field a) x -> Field a #

Pretty (Field a) # 

Methods

pretty :: Field a -> Doc #

prettyList :: [Field a] -> Doc #

type Rep (Field a) # 

data FieldList a #

Zero or more Fields, separated by , or ;.

Constructors

FieldList !a ![Field a] 

Instances

Functor FieldList # 

Methods

fmap :: (a -> b) -> FieldList a -> FieldList b #

(<$) :: a -> FieldList b -> FieldList a #

Annotated FieldList # 

Methods

ann :: Functor f => (a -> f a) -> FieldList a -> f (FieldList a) #

Eq a => Eq (FieldList a) # 

Methods

(==) :: FieldList a -> FieldList a -> Bool #

(/=) :: FieldList a -> FieldList a -> Bool #

Data a => Data (FieldList a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldList a -> c (FieldList a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldList a) #

toConstr :: FieldList a -> Constr #

dataTypeOf :: FieldList a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FieldList a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldList a)) #

gmapT :: (forall b. Data b => b -> b) -> FieldList a -> FieldList a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldList a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldList a -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldList a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldList a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldList a -> m (FieldList a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldList a -> m (FieldList a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldList a -> m (FieldList a) #

Show a => Show (FieldList a) # 
Generic (FieldList a) # 

Associated Types

type Rep (FieldList a) :: * -> * #

Methods

from :: FieldList a -> Rep (FieldList a) x #

to :: Rep (FieldList a) x -> FieldList a #

type Rep (FieldList a) # 
type Rep (FieldList a) = D1 (MetaData "FieldList" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) (C1 (MetaCons "FieldList" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 [Field a]))))

data Binop a #

Constructors

Plus !a

+

Minus !a

-

Mult !a

*

FloatDiv !a

/

FloorDiv !a

//

Exponent !a

^

Modulo !a

%

BitwiseAnd !a

&

BitwiseXor !a

~

BitwiseOr !a

|

Rshift !a

>>

Lshift !a

<<

Concat !a

..

Lt !a

<

Leq !a

<=

Gt !a

>

Geq !a

>=

Eq !a

==

Neq !a

~=

And !a

and

Or !a

or

Instances

Functor Binop # 

Methods

fmap :: (a -> b) -> Binop a -> Binop b #

(<$) :: a -> Binop b -> Binop a #

Annotated Binop # 

Methods

ann :: Functor f => (a -> f a) -> Binop a -> f (Binop a) #

Eq a => Eq (Binop a) # 

Methods

(==) :: Binop a -> Binop a -> Bool #

(/=) :: Binop a -> Binop a -> Bool #

Data a => Data (Binop a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Binop a -> c (Binop a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Binop a) #

toConstr :: Binop a -> Constr #

dataTypeOf :: Binop a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Binop a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binop a)) #

gmapT :: (forall b. Data b => b -> b) -> Binop a -> Binop a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binop a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binop a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Binop a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Binop a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Binop a -> m (Binop a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Binop a -> m (Binop a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Binop a -> m (Binop a) #

Show a => Show (Binop a) # 

Methods

showsPrec :: Int -> Binop a -> ShowS #

show :: Binop a -> String #

showList :: [Binop a] -> ShowS #

Generic (Binop a) # 

Associated Types

type Rep (Binop a) :: * -> * #

Methods

from :: Binop a -> Rep (Binop a) x #

to :: Rep (Binop a) x -> Binop a #

Pretty (Binop a) # 

Methods

pretty :: Binop a -> Doc #

prettyList :: [Binop a] -> Doc #

type Rep (Binop a) # 
type Rep (Binop a) = D1 (MetaData "Binop" "Language.Lua.Syntax" "language-lua2-0.1.0.5-6mkIMHJDToh907hED0cSGN" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Plus" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Minus" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) ((:+:) (C1 (MetaCons "Mult" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "FloatDiv" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "FloorDiv" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))))) ((:+:) ((:+:) (C1 (MetaCons "Exponent" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Modulo" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) ((:+:) (C1 (MetaCons "BitwiseAnd" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "BitwiseXor" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "BitwiseOr" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Rshift" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Lshift" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) ((:+:) (C1 (MetaCons "Concat" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "Lt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Leq" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))))) ((:+:) ((:+:) (C1 (MetaCons "Gt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "Geq" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Eq" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))) ((:+:) (C1 (MetaCons "Neq" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) ((:+:) (C1 (MetaCons "And" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Or" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))))))

data Unop a #

Constructors

Negate !a

-

Not !a

not

Length !a

#

BitwiseNot !a

~

Instances

Functor Unop # 

Methods

fmap :: (a -> b) -> Unop a -> Unop b #

(<$) :: a -> Unop b -> Unop a #

Annotated Unop # 

Methods

ann :: Functor f => (a -> f a) -> Unop a -> f (Unop a) #

Eq a => Eq (Unop a) # 

Methods

(==) :: Unop a -> Unop a -> Bool #

(/=) :: Unop a -> Unop a -> Bool #

Data a => Data (Unop a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unop a -> c (Unop a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Unop a) #

toConstr :: Unop a -> Constr #

dataTypeOf :: Unop a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Unop a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Unop a)) #

gmapT :: (forall b. Data b => b -> b) -> Unop a -> Unop a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unop a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unop a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Unop a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unop a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unop a -> m (Unop a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unop a -> m (Unop a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unop a -> m (Unop a) #

Show a => Show (Unop a) # 

Methods

showsPrec :: Int -> Unop a -> ShowS #

show :: Unop a -> String #

showList :: [Unop a] -> ShowS #

Generic (Unop a) # 

Associated Types

type Rep (Unop a) :: * -> * #

Methods

from :: Unop a -> Rep (Unop a) x #

to :: Rep (Unop a) x -> Unop a #

Pretty (Unop a) # 

Methods

pretty :: Unop a -> Doc #

prettyList :: [Unop a] -> Doc #

type Rep (Unop a) # 

Annotated typeclass

class Functor ast => Annotated ast where #

Minimal complete definition

ann

Methods

ann :: Lens' (ast a) a #

Instances

Annotated Unop # 

Methods

ann :: Functor f => (a -> f a) -> Unop a -> f (Unop a) #

Annotated Binop # 

Methods

ann :: Functor f => (a -> f a) -> Binop a -> f (Binop a) #

Annotated FieldList # 

Methods

ann :: Functor f => (a -> f a) -> FieldList a -> f (FieldList a) #

Annotated Field # 

Methods

ann :: Functor f => (a -> f a) -> Field a -> f (Field a) #

Annotated TableConstructor # 

Methods

ann :: Functor f => (a -> f a) -> TableConstructor a -> f (TableConstructor a) #

Annotated FunctionBody # 

Methods

ann :: Functor f => (a -> f a) -> FunctionBody a -> f (FunctionBody a) #

Annotated FunctionArgs # 

Methods

ann :: Functor f => (a -> f a) -> FunctionArgs a -> f (FunctionArgs a) #

Annotated FunctionCall # 

Methods

ann :: Functor f => (a -> f a) -> FunctionCall a -> f (FunctionCall a) #

Annotated PrefixExpression # 

Methods

ann :: Functor f => (a -> f a) -> PrefixExpression a -> f (PrefixExpression a) #

Annotated ExpressionList1 # 

Methods

ann :: Functor f => (a -> f a) -> ExpressionList1 a -> f (ExpressionList1 a) #

Annotated ExpressionList # 

Methods

ann :: Functor f => (a -> f a) -> ExpressionList a -> f (ExpressionList a) #

Annotated Expression # 

Methods

ann :: Functor f => (a -> f a) -> Expression a -> f (Expression a) #

Annotated VariableList1 # 

Methods

ann :: Functor f => (a -> f a) -> VariableList1 a -> f (VariableList1 a) #

Annotated Variable # 

Methods

ann :: Functor f => (a -> f a) -> Variable a -> f (Variable a) #

Annotated FunctionName # 

Methods

ann :: Functor f => (a -> f a) -> FunctionName a -> f (FunctionName a) #

Annotated ReturnStatement # 

Methods

ann :: Functor f => (a -> f a) -> ReturnStatement a -> f (ReturnStatement a) #

Annotated Statement # 

Methods

ann :: Functor f => (a -> f a) -> Statement a -> f (Statement a) #

Annotated Block # 

Methods

ann :: Functor f => (a -> f a) -> Block a -> f (Block a) #

Annotated IdentList1 # 

Methods

ann :: Functor f => (a -> f a) -> IdentList1 a -> f (IdentList1 a) #

Annotated IdentList # 

Methods

ann :: Functor f => (a -> f a) -> IdentList a -> f (IdentList a) #

Annotated Ident # 

Methods

ann :: Functor f => (a -> f a) -> Ident a -> f (Ident a) #