Safe Haskell	None
Language	Haskell2010

Text.Ginger.AST

Description

Implements Ginger's Abstract Syntax Tree.

Synopsis

Documentation

type VarName = Text #

A context variable name.

data Template a #

Top-level data structure, representing a fully parsed template.

Constructors

Template
Fields templateBody :: Statement a templateBlocks :: HashMap VarName (Block a) templateParent :: Maybe (Template a)

Instances

Functor Template #
Methods fmap :: (a -> b) -> Template a -> Template b # (<$) :: a -> Template b -> Template a #
Annotated Template #
Methods annotation :: Template p -> p #
Show a => Show (Template a) #
Methods showsPrec :: Int -> Template a -> ShowS # show :: Template a -> String # showList :: [Template a] -> ShowS #
Optimizable (Template a) #
Methods optimize :: Template a -> Template a #

data Macro a #

A macro definition ( {% macro %} )

Constructors

Macro
Fields macroArgs :: [VarName] macroBody :: Statement a

Instances

Functor Macro #
Methods fmap :: (a -> b) -> Macro a -> Macro b # (<$) :: a -> Macro b -> Macro a #
Annotated Macro #
Methods annotation :: Macro p -> p #
Show a => Show (Macro a) #
Methods showsPrec :: Int -> Macro a -> ShowS # show :: Macro a -> String # showList :: [Macro a] -> ShowS #
Optimizable (Macro a) #
Methods optimize :: Macro a -> Macro a #

data Block a #

A block definition ( {% block %} )

Constructors

Block
Fields blockBody :: Statement a

Instances

Functor Block #
Methods fmap :: (a -> b) -> Block a -> Block b # (<$) :: a -> Block b -> Block a #
Annotated Block #
Methods annotation :: Block p -> p #
Show a => Show (Block a) #
Methods showsPrec :: Int -> Block a -> ShowS # show :: Block a -> String # showList :: [Block a] -> ShowS #
Optimizable (Block a) #
Methods optimize :: Block a -> Block a #

data Statement a #

Ginger statements.

Constructors

MultiS a [Statement a]	A sequence of multiple statements
ScopedS a (Statement a)	Run wrapped statement in a local scope
IndentS a (Expression a) (Statement a)	Establish an indented context around the wrapped statement
LiteralS a Html	Literal output (anything outside of any tag)
InterpolationS a (Expression a)	{{ expression }}
ExpressionS a (Expression a)	Evaluate expression
IfS a (Expression a) (Statement a) (Statement a)	{% if expression %}statement{% else %}statement{% endif %}
SwitchS a (Expression a) [(Expression a, Statement a)] (Statement a)	{% switch expression %}{% case expression %}statement{% endcase %}...{% default %}statement{% enddefault %}{% endswitch %}
ForS a (Maybe VarName) VarName (Expression a) (Statement a)	{% for index, varname in expression %}statement{% endfor %}
SetVarS a VarName (Expression a)	{% set varname = expr %}
DefMacroS a VarName (Macro a)	{% macro varname %}statements{% endmacro %}
BlockRefS a VarName
PreprocessedIncludeS a (Template a)	{% include "template" %}
NullS a	The do-nothing statement (NOP)
TryCatchS a (Statement a) [CatchBlock a] (Statement a)	Try catch finally

Instances

Functor Statement #
Methods fmap :: (a -> b) -> Statement a -> Statement b # (<$) :: a -> Statement b -> Statement a #
Annotated Statement #
Methods annotation :: Statement p -> p #
Show a => Show (Statement a) #
Methods showsPrec :: Int -> Statement a -> ShowS # show :: Statement a -> String # showList :: [Statement a] -> ShowS #
Optimizable (Statement a) #
Methods optimize :: Statement a -> Statement a #

stmtAnnotation :: Statement p -> p #

data CatchBlock a #

A catch block

Constructors

Catch
Fields catchWhat :: Maybe Text catchCaptureAs :: Maybe VarName catchBody :: Statement a

Instances

Functor CatchBlock #
Methods fmap :: (a -> b) -> CatchBlock a -> CatchBlock b # (<$) :: a -> CatchBlock b -> CatchBlock a #
Show a => Show (CatchBlock a) #
Methods showsPrec :: Int -> CatchBlock a -> ShowS # show :: CatchBlock a -> String # showList :: [CatchBlock a] -> ShowS #

data Expression a #

Expressions, building blocks for the expression minilanguage.

Constructors

StringLiteralE a Text	String literal expression: "foobar"
NumberLiteralE a Scientific	Numeric literal expression: 123.4
BoolLiteralE a Bool	Boolean literal expression: true
NullLiteralE a	Literal null
VarE a VarName	Variable reference: foobar
ListE a [Expression a]	List construct: [ expr, expr, expr ]
ObjectE a [(Expression a, Expression a)]	Object construct: { expr: expr, expr: expr, ... }
MemberLookupE a (Expression a) (Expression a)	foo[bar] (also dot access)
CallE a (Expression a) [(Maybe Text, Expression a)]	foo(bar=baz, quux)
LambdaE a [Text] (Expression a)	(foo, bar) -> expr
TernaryE a (Expression a) (Expression a) (Expression a)	expr ? expr : expr
DoE a (Statement a)	do { statement; }

Instances

Functor Expression #
Methods fmap :: (a -> b) -> Expression a -> Expression b # (<$) :: a -> Expression b -> Expression a #
Annotated Expression #
Methods annotation :: Expression p -> p #
Show a => Show (Expression a) #
Methods showsPrec :: Int -> Expression a -> ShowS # show :: Expression a -> String # showList :: [Expression a] -> ShowS #
Optimizable (Expression a) #
Methods optimize :: Expression a -> Expression a #

exprAnnotation :: Expression p -> p #

class Annotated f where #

Minimal complete definition

annotation

Methods

annotation :: f p -> p #

Instances

Annotated Expression #
Methods annotation :: Expression p -> p #
Annotated Statement #
Methods annotation :: Statement p -> p #
Annotated Block #
Methods annotation :: Block p -> p #
Annotated Macro #
Methods annotation :: Macro p -> p #
Annotated Template #
Methods annotation :: Template p -> p #