Language.Lua.Syntax

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

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

Annotated Ident

Eq a => Eq (Ident a)

Data a => Data (Ident a)

Show a => Show (Ident a)

Generic (Ident a)

Pretty (Ident a)

Typeable (* -> *) Ident

type Rep (Ident a)

data IdentList a

Zero or more Idents.

Constructors

IdentList !a ![Ident a]

Instances

Functor IdentList

Annotated IdentList

Eq a => Eq (IdentList a)

Data a => Data (IdentList a)

Show a => Show (IdentList a)

Generic (IdentList a)

Typeable (* -> *) IdentList

type Rep (IdentList a)

data IdentList1 a

One or more Idents.

Constructors

IdentList1 !a !(NonEmpty (Ident a))

Instances

Functor IdentList1

Annotated IdentList1

Eq a => Eq (IdentList1 a)

Data a => Data (IdentList1 a)

Show a => Show (IdentList1 a)

Generic (IdentList1 a)

Typeable (* -> *) IdentList1

type Rep (IdentList1 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

Annotated Block

Eq a => Eq (Block a)

Data a => Data (Block a)

Show a => Show (Block a)

Generic (Block a)

Pretty (Block a)

Typeable (* -> *) Block

type Rep (Block a)

data Statement a

A statement.

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

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

Annotated Statement

Eq a => Eq (Statement a)

Data a => Data (Statement a)

Show a => Show (Statement a)

Generic (Statement a)

Pretty (Statement a)

Typeable (* -> *) Statement

type Rep (Statement a)

data ReturnStatement a

Constructors

ReturnStatement !a !(ExpressionList a)

return exp1, exp2

Instances

Functor ReturnStatement

Annotated ReturnStatement

Eq a => Eq (ReturnStatement a)

Data a => Data (ReturnStatement a)

Show a => Show (ReturnStatement a)

Generic (ReturnStatement a)

Pretty (ReturnStatement a)

Typeable (* -> *) ReturnStatement

type Rep (ReturnStatement a)

data FunctionName a

Constructors

FunctionName !a !(IdentList1 a) !(Maybe (Ident a))

foo.bar:baz

Instances

Functor FunctionName

Annotated FunctionName

Eq a => Eq (FunctionName a)

Data a => Data (FunctionName a)

Show a => Show (FunctionName a)

Generic (FunctionName a)

Pretty (FunctionName a)

Typeable (* -> *) FunctionName

type Rep (FunctionName a)

data Variable a

A variable.

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

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

Annotated Variable

Eq a => Eq (Variable a)

Data a => Data (Variable a)

Show a => Show (Variable a)

Generic (Variable a)

Pretty (Variable a)

Typeable (* -> *) Variable

type Rep (Variable a)

data VariableList1 a

One or more Variables.

Constructors

VariableList1 !a !(NonEmpty (Variable a))

Instances

Functor VariableList1

Annotated VariableList1

Eq a => Eq (VariableList1 a)

Data a => Data (VariableList1 a)

Show a => Show (VariableList1 a)

Generic (VariableList1 a)

Typeable (* -> *) VariableList1

type Rep (VariableList1 a)

data Expression a

An expression.

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

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

Annotated Expression

Eq a => Eq (Expression a)

Data a => Data (Expression a)

Show a => Show (Expression a)

Generic (Expression a)

Pretty (Expression a)

Typeable (* -> *) Expression

type Rep (Expression a)

data ExpressionList a

Zero or more Expressions.

Constructors

ExpressionList !a ![Expression a]

Instances

Functor ExpressionList

Annotated ExpressionList

Eq a => Eq (ExpressionList a)

Data a => Data (ExpressionList a)

Show a => Show (ExpressionList a)

Generic (ExpressionList a)

Typeable (* -> *) ExpressionList

type Rep (ExpressionList a)

data ExpressionList1 a

One or more Expressions.

Constructors

ExpressionList1 !a !(NonEmpty (Expression a))

Instances

Functor ExpressionList1

Annotated ExpressionList1

Eq a => Eq (ExpressionList1 a)

Data a => Data (ExpressionList1 a)

Show a => Show (ExpressionList1 a)

Generic (ExpressionList1 a)

Typeable (* -> *) ExpressionList1

type Rep (ExpressionList1 a)

data PrefixExpression a

Constructors

PrefixVar !a !(Variable a)

PrefixFunCall !a !(FunctionCall a)

Parens !a !(Expression a)

Instances

Functor PrefixExpression

Annotated PrefixExpression

Eq a => Eq (PrefixExpression a)

Data a => Data (PrefixExpression a)

Show a => Show (PrefixExpression a)

Generic (PrefixExpression a)

Pretty (PrefixExpression a)

Typeable (* -> *) PrefixExpression

type Rep (PrefixExpression a)

data FunctionCall a

A function call. May be a statement or an expression.

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

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

Constructors

FunctionCall !a !(PrefixExpression a) !(FunctionArgs a)

MethodCall !a !(PrefixExpression a) !(Ident a) !(FunctionArgs a)

Instances

Functor FunctionCall

Annotated FunctionCall

Eq a => Eq (FunctionCall a)

Data a => Data (FunctionCall a)

Show a => Show (FunctionCall a)

Generic (FunctionCall a)

Pretty (FunctionCall a)

Typeable (* -> *) FunctionCall

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

Annotated FunctionArgs

Eq a => Eq (FunctionArgs a)

Data a => Data (FunctionArgs a)

Show a => Show (FunctionArgs a)

Generic (FunctionArgs a)

Pretty (FunctionArgs a)

Typeable (* -> *) FunctionArgs

type Rep (FunctionArgs a)

data FunctionBody a

Constructors

FunctionBody !a !(IdentList a) !Bool !(Block a)

(x, y, ...) block end

Instances

Functor FunctionBody

Annotated FunctionBody

Eq a => Eq (FunctionBody a)

Data a => Data (FunctionBody a)

Show a => Show (FunctionBody a)

Generic (FunctionBody a)

Pretty (FunctionBody a)

Typeable (* -> *) FunctionBody

type Rep (FunctionBody a)

data TableConstructor a

A table constructor.

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

Constructors

TableConstructor !a !(FieldList a)

{ x = 5, [f(1)] = 6, 7 }

Instances

Functor TableConstructor

Annotated TableConstructor

Eq a => Eq (TableConstructor a)

Data a => Data (TableConstructor a)

Show a => Show (TableConstructor a)

Generic (TableConstructor a)

Pretty (TableConstructor a)

Typeable (* -> *) TableConstructor

type Rep (TableConstructor 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

Annotated Field

Eq a => Eq (Field a)

Data a => Data (Field a)

Show a => Show (Field a)

Generic (Field a)

Pretty (Field a)

Typeable (* -> *) Field

type Rep (Field a)

data FieldList a

Zero or more Fields, separated by , or ;.

Constructors

FieldList !a ![Field a]

Instances

Functor FieldList

Annotated FieldList

Eq a => Eq (FieldList a)

Data a => Data (FieldList a)

Show a => Show (FieldList a)

Generic (FieldList a)

Typeable (* -> *) FieldList

type Rep (FieldList 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

Annotated Binop

Eq a => Eq (Binop a)

Data a => Data (Binop a)

Show a => Show (Binop a)

Generic (Binop a)

Pretty (Binop a)

Typeable (* -> *) Binop

type Rep (Binop a)

data Unop a

Constructors

Negate !a

-

Not !a

not

Length !a

#

BitwiseNot !a

~

Instances

Functor Unop

Annotated Unop

Eq a => Eq (Unop a)

Data a => Data (Unop a)

Show a => Show (Unop a)

Generic (Unop a)

Pretty (Unop a)

Typeable (* -> *) Unop

type Rep (Unop a)

Annotated typeclass

class Functor ast => Annotated ast where

Methods

ann :: Lens' (ast a) a

Instances

Annotated Unop

Annotated Binop

Annotated FieldList

Annotated Field

Annotated TableConstructor

Annotated FunctionBody

Annotated FunctionArgs

Annotated FunctionCall

Annotated PrefixExpression

Annotated ExpressionList1

Annotated ExpressionList

Annotated Expression

Annotated VariableList1

Annotated Variable

Annotated FunctionName

Annotated ReturnStatement

Annotated Statement

Annotated Block

Annotated IdentList1

Annotated IdentList

Annotated Ident