Language.Lua.Annotated.Syntax

Lua 5.2 syntax tree, as specified in http://www.lua.org/manual/5.2/manual.html#9. Annotation implementation is inspired by haskell-src-exts.

Documentation

data Name a

Constructors

Name a String

Instances

Functor Name

Eq a => Eq (Name a)

Data a => Data (Name a)

Show a => Show (Name a)

Typeable (* -> *) Name

data Stat a

Constructors

Assign a [Var a] [Exp a]

var1, var2 .. = exp1, exp2 ..

FunCall a (FunCall a)

function call

Label a (Name a)

label for goto

Break a

break

Goto a (Name a)

goto label

Do a (Block a)

do .. end

While a (Exp a) (Block a)

while .. do .. end

Repeat a (Block a) (Exp a)

repeat .. until ..

If a [(Exp a, Block a)] (Maybe (Block a))

if .. then .. [elseif ..] [else ..] end

ForRange a (Name a) (Exp a) (Exp a) (Maybe (Exp a)) (Block a)

for x=start, end [, step] do .. end

ForIn a [Name a] [Exp a] (Block a)

for x in .. do .. end

FunAssign a (FunName a) (FunBody a)

function <var> (..) .. end

LocalFunAssign a (Name a) (FunBody a)

local function <var> (..) .. end

LocalAssign a [Name a] (Maybe [Exp a])

local var1, var2 .. = exp1, exp2 ..

EmptyStat a

;

Instances

Functor Stat

Annotated Stat

Eq a => Eq (Stat a)

Data a => Data (Stat a)

Show a => Show (Stat a)

Typeable (* -> *) Stat

data Exp a

Constructors

Nil a

Bool a Bool

Number a String

String a String

Vararg a

...

EFunDef a (FunDef a)

function (..) .. end

PrefixExp a (PrefixExp a)

TableConst a (Table a)

table constructor

Binop a (Binop a) (Exp a) (Exp a)

binary operators, + - * ^ % .. <= >= == ~= and or

Unop a (Unop a) (Exp a)

unary operators, - not #

Instances

Functor Exp

Annotated Exp

Eq a => Eq (Exp a)

Data a => Data (Exp a)

Show a => Show (Exp a)

Typeable (* -> *) Exp

data Var a

Constructors

VarName a (Name a)

variable

Select a (PrefixExp a) (Exp a)

table[exp]

SelectName a (PrefixExp a) (Name a)

table.variable

Instances

Functor Var

Annotated Var

Eq a => Eq (Var a)

Data a => Data (Var a)

Show a => Show (Var a)

Typeable (* -> *) Var

data Binop a

Constructors

Add a

Sub a

Mul a

Div a

Exp a

Mod a

Concat a

LT a

LTE a

GT a

GTE a

EQ a

NEQ a

And a

Or a

Instances

Functor Binop

Annotated Binop

Eq a => Eq (Binop a)

Data a => Data (Binop a)

Show a => Show (Binop a)

Typeable (* -> *) Binop

data Unop a

Constructors

Neg a

Not a

Len a

Instances

Functor Unop

Annotated Unop

Eq a => Eq (Unop a)

Data a => Data (Unop a)

Show a => Show (Unop a)

Typeable (* -> *) Unop

data PrefixExp a

Constructors

PEVar a (Var a)

PEFunCall a (FunCall a)

Paren a (Exp a)

Instances

Functor PrefixExp

Annotated PrefixExp

Eq a => Eq (PrefixExp a)

Data a => Data (PrefixExp a)

Show a => Show (PrefixExp a)

Typeable (* -> *) PrefixExp

data Table a

Constructors

Table a [TableField a]

list of table fields

Instances

Functor Table

Annotated Table

Eq a => Eq (Table a)

Data a => Data (Table a)

Show a => Show (Table a)

Typeable (* -> *) Table

data TableField a

Constructors

ExpField a (Exp a) (Exp a)

[exp] = exp

NamedField a (Name a) (Exp a)

name = exp

Field a (Exp a)

Instances

Functor TableField

Annotated TableField

Eq a => Eq (TableField a)

Data a => Data (TableField a)

Show a => Show (TableField a)

Typeable (* -> *) TableField

data Block a

A block is list of statements with optional return statement.

Constructors

Block a [Stat a] (Maybe [Exp a])

Instances

Functor Block

Annotated Block

Eq a => Eq (Block a)

Data a => Data (Block a)

Show a => Show (Block a)

Typeable (* -> *) Block

data FunName a

Constructors

FunName a (Name a) [Name a] (Maybe (Name a))

Instances

Functor FunName

Annotated FunName

Eq a => Eq (FunName a)

Data a => Data (FunName a)

Show a => Show (FunName a)

Typeable (* -> *) FunName

data FunDef a

Constructors

FunDef a (FunBody a)

Instances

Functor FunDef

Annotated FunDef

Eq a => Eq (FunDef a)

Data a => Data (FunDef a)

Show a => Show (FunDef a)

Typeable (* -> *) FunDef

data FunBody a

Constructors

FunBody a [Name a] (Maybe a) (Block a)

(args, vararg, block)

Instances

Functor FunBody

Annotated FunBody

Eq a => Eq (FunBody a)

Data a => Data (FunBody a)

Show a => Show (FunBody a)

Typeable (* -> *) FunBody

data FunCall a

Constructors

NormalFunCall a (PrefixExp a) (FunArg a)

prefixexp ( funarg )

MethodCall a (PrefixExp a) (Name a) (FunArg a)

prefixexp : name ( funarg )

Instances

Functor FunCall

Annotated FunCall

Eq a => Eq (FunCall a)

Data a => Data (FunCall a)

Show a => Show (FunCall a)

Typeable (* -> *) FunCall

data FunArg a

Constructors

Args a [Exp a]

list of args

TableArg a (Table a)

table constructor

StringArg a String

string

Instances

Functor FunArg

Annotated FunArg

Eq a => Eq (FunArg a)

Data a => Data (FunArg a)

Show a => Show (FunArg a)

Typeable (* -> *) FunArg

class Functor ast => Annotated ast where

Methods

ann :: ast l -> l

Retrieve the annotation of an AST node.

amap :: (l -> l) -> ast l -> ast 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 fmap.

Instances

Annotated FunArg

Annotated FunCall

Annotated FunBody

Annotated FunDef

Annotated FunName

Annotated Block

Annotated TableField

Annotated Table

Annotated PrefixExp

Annotated Unop

Annotated Binop

Annotated Var

Annotated Exp

Annotated Stat