template

Feb 23, 2026

Changes in this version

+ var ErrExpectedSliceOrArray = errors.New("expected slice or array")

Feb 12, 2026

Changes in this version

+ var ErrBreakNoArgs = errors.New("break does not take arguments")

+ var ErrCannotApplyUnaryPlus = errors.New("cannot apply unary plus")

+ var ErrCannotConvertNilToFloat = errors.New("cannot convert nil to float")

+ var ErrCannotConvertNilToInt = errors.New("cannot convert nil to int")

+ var ErrCannotConvertToFloat = errors.New("cannot convert value to float")

+ var ErrCannotConvertToInt = errors.New("cannot convert value to int")

+ var ErrCannotGetFieldFromNil = errors.New("cannot get field from nil")

+ var ErrCannotGetKeyFromNil = errors.New("cannot get key from nil")

+ var ErrCannotIndexNil = errors.New("cannot index nil")

+ var ErrCannotModuloTypes = errors.New("cannot modulo values of these types")

+ var ErrCannotNegate = errors.New("cannot negate value")

+ var ErrContinueNoArgs = errors.New("continue does not take arguments")

+ var ErrElifAfterElse = errors.New("elif cannot appear after else")

+ var ErrElseNoArgs = errors.New("else does not take arguments")

+ var ErrEndforNoArgs = errors.New("endfor does not take arguments")

+ var ErrEndifNoArgs = errors.New("endif does not take arguments")

+ var ErrExpectedInKeyword = errors.New("expected 'in' keyword")

+ var ErrExpectedSecondVariable = errors.New("expected second variable name after comma")

+ var ErrExpectedVariable = errors.New("expected variable name")

+ var ErrFilterExecutionFailed = errors.New("filter execution failed")

+ var ErrModuloByZero = errors.New("modulo by zero")

+ var ErrStructHasNoField = errors.New("struct has no field")

+ var ErrTagAlreadyRegistered = errors.New("tag already registered")

+ var ErrTypeHasNoField = errors.New("type has no field")

+ var ErrTypeHasNoLength = errors.New("type has no length")

+ var ErrTypeNotIndexable = errors.New("type is not indexable")

+ var ErrTypeNotIterable = errors.New("type is not iterable")

+ var ErrTypeNotMap = errors.New("type is not a map")

+ var ErrUnexpectedTokensAfterCollection = errors.New("unexpected tokens after collection")

+ var ErrUnexpectedTokensAfterCondition = errors.New("unexpected tokens after condition")

+ func HasFilter(name string) bool

+ func HasTag(name string) bool

+ func IsKeyword(ident string) bool

+ func IsSymbol(s string) bool

+ func ListFilters() []string

+ func ListTags() []string

+ func RegisterTag(name string, parser TagParser) error

+ func UnregisterFilter(name string)

+ func UnregisterTag(name string)

+ type BinaryOpNode struct

+ Col int

+ Left Expression

+ Line int

+ Operator string

+ Right Expression

+ func NewBinaryOpNode(operator string, left, right Expression, line, col int) *BinaryOpNode

+ func (n *BinaryOpNode) Evaluate(ctx *ExecutionContext) (*Value, error)

+ func (n *BinaryOpNode) Position() (int, int)

+ func (n *BinaryOpNode) String() string

+ type BreakError struct

+ func (e *BreakError) Error() string

+ type BreakNode struct

+ Col int

+ Line int

+ func (n *BreakNode) Execute(_ *ExecutionContext, _ io.Writer) error

+ func (n *BreakNode) Position() (int, int)

+ func (n *BreakNode) String() string

+ type ContinueError struct

+ func (e *ContinueError) Error() string

+ type ContinueNode struct

+ Col int

+ Line int

+ func (n *ContinueNode) Execute(_ *ExecutionContext, _ io.Writer) error

+ func (n *ContinueNode) Position() (int, int)

+ func (n *ContinueNode) String() string

+ type ExecutionContext struct

+ Private Context

+ Public Context

+ func NewChildContext(parent *ExecutionContext) *ExecutionContext

+ func NewExecutionContext(data map[string]any) *ExecutionContext

+ func (ec *ExecutionContext) Get(name string) (any, bool)

+ func (ec *ExecutionContext) Set(name string, value any)

+ type ExprParser struct

+ func NewExprParser(tokens []*Token) *ExprParser

+ func (p *ExprParser) ParseExpression() (Expression, error)

+ type Expression interface

+ Evaluate func(ctx *ExecutionContext) (*Value, error)

type FilterFunc

+ func GetFilter(name string) (FilterFunc, bool)

+ type FilterNode struct

+ Args []Expression

+ Col int

+ Expr Expression

+ Line int

+ Name string

+ func NewFilterNode(expr Expression, name string, args []Expression, line, col int) *FilterNode

+ func (n *FilterNode) Evaluate(ctx *ExecutionContext) (*Value, error)

+ func (n *FilterNode) Position() (int, int)

+ func (n *FilterNode) String() string

+ type ForNode struct

+ Body []Node

+ Col int

+ Collection Expression

+ Line int

+ Vars []string

+ func (n *ForNode) Execute(ctx *ExecutionContext, w io.Writer) error

+ func (n *ForNode) Position() (int, int)

+ func (n *ForNode) String() string

+ type IfBranch struct

+ Body []Node

+ Condition Expression

+ type IfNode struct

+ Branches []IfBranch

+ Col int

+ ElseBody []Node

+ Line int

+ func (n *IfNode) Execute(ctx *ExecutionContext, w io.Writer) error

+ func (n *IfNode) Position() (int, int)

+ func (n *IfNode) String() string

type Lexer

+ func NewLexer(input string) *Lexer

+ func (l *Lexer) Tokenize() ([]*Token, error)

+ type LexerError struct

+ Col int

+ Line int

+ Message string

+ func (e *LexerError) Error() string

+ type LiteralNode struct

+ Col int

+ Line int

+ Value any

+ func NewLiteralNode(value any, line, col int) *LiteralNode

+ func (n *LiteralNode) Evaluate(_ *ExecutionContext) (*Value, error)

+ func (n *LiteralNode) Position() (int, int)

+ func (n *LiteralNode) String() string

type LoopContext

+ Counter int

+ Parent *LoopContext

+ Revcounter int

type Node

+ Position func() (line, col int)

+ String func() string

+ type OutputNode struct

+ Col int

+ Expr Expression

+ Line int

+ func NewOutputNode(expr Expression, line, col int) *OutputNode

+ func (n *OutputNode) Execute(ctx *ExecutionContext, w io.Writer) error

+ func (n *OutputNode) Position() (int, int)

+ func (n *OutputNode) String() string

+ type ParseError struct

+ Col int

+ Line int

+ Message string

+ func (e *ParseError) Error() string

type Parser

+ func (p *Parser) Advance()

+ func (p *Parser) Current() *Token

+ func (p *Parser) Error(msg string) error

+ func (p *Parser) Errorf(format string, args ...any) error

+ func (p *Parser) ExpectIdentifier() (*Token, error)

+ func (p *Parser) Match(tokenType TokenType, value string) *Token

+ func (p *Parser) ParseExpression() (Expression, error)

+ func (p *Parser) ParseUntil(endTags ...string) ([]Statement, string, error)

+ func (p *Parser) ParseUntilWithArgs(endTags ...string) ([]Statement, string, *Parser, error)

+ func (p *Parser) Remaining() int

+ type PropertyAccessNode struct

+ Col int

+ Line int

+ Object Expression

+ Property string

+ func NewPropertyAccessNode(object Expression, property string, line, col int) *PropertyAccessNode

+ func (n *PropertyAccessNode) Evaluate(ctx *ExecutionContext) (*Value, error)

+ func (n *PropertyAccessNode) Position() (int, int)

+ func (n *PropertyAccessNode) String() string

+ type Registry struct

+ func NewRegistry() *Registry

+ func (r *Registry) Filter(name string) (FilterFunc, bool)

+ func (r *Registry) Has(name string) bool

+ func (r *Registry) List() []string

+ func (r *Registry) Register(name string, fn FilterFunc)

+ func (r *Registry) Unregister(name string)

+ type Statement interface

+ Execute func(ctx *ExecutionContext, writer io.Writer) error

+ type SubscriptNode struct

+ Col int

+ Index Expression

+ Line int

+ Object Expression

+ func NewSubscriptNode(object, index Expression, line, col int) *SubscriptNode

+ func (n *SubscriptNode) Evaluate(ctx *ExecutionContext) (*Value, error)

+ func (n *SubscriptNode) Position() (int, int)

+ func (n *SubscriptNode) String() string

+ type TagParser func(doc *Parser, start *Token, arguments *Parser) (Statement, error)

+ func Tag(name string) (TagParser, bool)

type Template

+ func Compile(source string) (*Template, error)

+ func (t *Template) Render(data map[string]any) (string, error)

+ type TextNode struct

+ Col int

+ Line int

+ Text string

+ func NewTextNode(text string, line, col int) *TextNode

+ func (n *TextNode) Execute(_ *ExecutionContext, w io.Writer) error

+ func (n *TextNode) Position() (int, int)

+ func (n *TextNode) String() string

type Token

+ Col int

+ Line int

+ Type TokenType

+ Value string

+ func (t *Token) String() string

type TokenType

+ const TokenError

+ const TokenSymbol

+ const TokenTagBegin

+ const TokenTagEnd

+ const TokenText

+ const TokenVarBegin

+ const TokenVarEnd

+ func (t TokenType) String() string

+ type UnaryOpNode struct

+ Col int

+ Line int

+ Operand Expression

+ Operator string

+ func NewUnaryOpNode(operator string, operand Expression, line, col int) *UnaryOpNode

+ func (n *UnaryOpNode) Evaluate(ctx *ExecutionContext) (*Value, error)

+ func (n *UnaryOpNode) Position() (int, int)

+ func (n *UnaryOpNode) String() string

type Value

+ func (v *Value) Compare(other *Value) (int, error)

+ func (v *Value) Equals(other *Value) bool

+ func (v *Value) Field(name string) (*Value, error)

+ func (v *Value) Index(i int) (*Value, error)

+ func (v *Value) Interface() any

+ func (v *Value) IsNil() bool

+ func (v *Value) IsTrue() bool

+ func (v *Value) Iterate(fn func(idx, count int, key, val *Value) bool) error

+ func (v *Value) Key(key any) (*Value, error)

+ func (v *Value) Len() (int, error)

+ func (v *Value) String() string

type VariableNode

+ Col int

+ Line int

+ func NewVariableNode(name string, line, col int) *VariableNode

+ func (n *VariableNode) Position() (int, int)

+ func (n *VariableNode) String() string

Feb 8, 2026

Changes in this version

+ const NodeTypeElif

+ const NodeTypeElse

+ const NodeTypeFor

+ const NodeTypeIf

+ const NodeTypeText

+ const NodeTypeVariable

Jan 29, 2026

Changes in this version

+ type ContextBuilder struct

+ func NewContextBuilder() *ContextBuilder

+ func (cb *ContextBuilder) Build() (Context, error)

+ func (cb *ContextBuilder) KeyValue(key string, value interface{}) *ContextBuilder

+ func (cb *ContextBuilder) Struct(v interface{}) *ContextBuilder

Oct 6, 2025

Changes in this version

+ type NilLiteralNode struct

+ func (n *NilLiteralNode) Evaluate(_ Context) (*Value, error)

type Value

+ func (v *Value) In(haystack *Value) (*Value, error)

Sep 10, 2025

Changes in this version

+ type LoopContext struct

+ First bool

+ Index int

+ Last bool

+ Length int

+ Revindex int

Jul 9, 2025

Changes in this version

+ const NodeTypeBreak

+ const NodeTypeContinue

+ var ErrBreakOutsideLoop = errors.New("break statement outside of loop")

+ var ErrContinueOutsideLoop = errors.New("continue statement outside of loop")

+ var ErrIntegerOverflow = errors.New("unsigned integer value exceeds maximum int64 value")

+ var ErrMultipleElseStatements = errors.New(...)

+ type ControlFlow int

+ const ControlFlowBreak

+ const ControlFlowContinue

+ const ControlFlowNone

Jun 4, 2025

Changes in this version

type Value

+ Struct interface{}

type ValueType

+ const TypeNil

+ const TypeStruct

Apr 13, 2025

Changes in this version

+ var ErrCannotAccessProperty = errors.New("cannot access property")

+ var ErrCannotAddTypes = errors.New("cannot add values of these types")

+ var ErrCannotCompareTypes = errors.New("cannot compare values of these types")

+ var ErrCannotConvertToBool = errors.New("cannot convert type to boolean")

+ var ErrCannotDivideTypes = errors.New("cannot divide values of these types")

+ var ErrCannotMultiplyTypes = errors.New("cannot multiply values of these types")

+ var ErrCannotSubtractTypes = errors.New("cannot subtract values of these types")

+ var ErrDivisionByZero = errors.New("division by zero")

+ var ErrExpectedFilterName = errors.New("expected filter name after '|'")

+ var ErrExpectedRParen = errors.New("expected ')'")

+ var ErrIndexOutOfRange = errors.New("index out of range")

+ var ErrInvalidArrayIndex = errors.New("invalid array index")

+ var ErrInvalidFilterName = errors.New("invalid filter name")

+ var ErrInvalidIndexType = errors.New("invalid index type")

+ var ErrInvalidNumber = errors.New("invalid number")

+ var ErrInvalidVariableAccess = errors.New("invalid variable access")

+ var ErrNonObjectProperty = errors.New("cannot access property of non-object")

+ var ErrNonStructProperty = errors.New("cannot access property of non-struct value")

+ var ErrUndefinedProperty = errors.New("undefined property")

+ var ErrUndefinedVariable = errors.New("undefined variable")

+ var ErrUnexpectedCharacter = errors.New("unexpected character")

+ var ErrUnexpectedToken = errors.New("unexpected token")

+ var ErrUnknownFilterArgumentType = errors.New("unknown argument type")

+ var ErrUnknownNodeType = errors.New("unknown node type")

+ var ErrUnsupportedArrayType = errors.New("unsupported array type")

+ var ErrUnsupportedCollectionType = errors.New("unsupported collection type for for loop")

+ var ErrUnsupportedOperator = errors.New("unsupported operator")

+ var ErrUnsupportedType = errors.New("unsupported type")

+ var ErrUnsupportedUnaryOp = errors.New("unsupported unary operator")

+ var ErrUnterminatedString = errors.New("unterminated string literal")

+ type BinaryExpressionNode struct

+ Left ExpressionNode

+ Operator string

+ Right ExpressionNode

+ func (n *BinaryExpressionNode) Evaluate(ctx Context) (*Value, error)

+ type BooleanLiteralNode struct

+ Value bool

+ func (n *BooleanLiteralNode) Evaluate(ctx Context) (*Value, error)

+ type ExpressionNode interface

+ Evaluate func(ctx Context) (*Value, error)

+ type FilterExpressionNode struct

+ Expression ExpressionNode

+ Filter string

+ func (n *FilterExpressionNode) Evaluate(ctx Context) (*Value, error)

+ type Grammar struct

+ func NewGrammar(tokens []Token) *Grammar

+ func (g *Grammar) Parse() (ExpressionNode, error)

+ type Lexer struct

+ func (l *Lexer) Lex() ([]Token, error)

type Node

+ Collection string

+ EndText string

+ type NumberLiteralNode struct

+ Value float64

+ func (n *NumberLiteralNode) Evaluate(ctx Context) (*Value, error)

+ type StringLiteralNode struct

+ Value string

+ func (n *StringLiteralNode) Evaluate(ctx Context) (*Value, error)

+ type Token struct

+ Typ TokenType

+ Val string

+ type TokenType int

+ const TokenArithOp

+ const TokenBool

+ const TokenDot

+ const TokenEOF

+ const TokenFilter

+ const TokenIdentifier

+ const TokenLParen

+ const TokenNot

+ const TokenNumber

+ const TokenOperator

+ const TokenPipe

+ const TokenRParen

+ const TokenString

+ type UnaryExpressionNode struct

+ Operator string

+ Right ExpressionNode

+ func (n *UnaryExpressionNode) Evaluate(ctx Context) (*Value, error)

+ type Value struct

+ Bool bool

+ Float float64

+ Int int64

+ Map map[string]interface{}

+ Slice interface{}

+ Str string

+ Type ValueType

+ func NewValue(v interface{}) (*Value, error)

+ func (v *Value) Add(right *Value) (*Value, error)

+ func (v *Value) And(right *Value) (*Value, error)

+ func (v *Value) Divide(right *Value) (*Value, error)

+ func (v *Value) Equal(right *Value) (*Value, error)

+ func (v *Value) GreaterEqual(right *Value) (*Value, error)

+ func (v *Value) GreaterThan(right *Value) (*Value, error)

+ func (v *Value) LessEqual(right *Value) (*Value, error)

+ func (v *Value) LessThan(right *Value) (*Value, error)

+ func (v *Value) Multiply(right *Value) (*Value, error)

+ func (v *Value) NotEqual(right *Value) (*Value, error)

+ func (v *Value) Or(right *Value) (*Value, error)

+ func (v *Value) Subtract(right *Value) (*Value, error)

+ type ValueType int

+ const TypeBool

+ const TypeFloat

+ const TypeInt

+ const TypeMap

+ const TypeSlice

+ const TypeString

+ type VariableNode struct

+ Name string

+ func (n *VariableNode) Evaluate(ctx Context) (*Value, error)

Apr 2, 2024

Changes in this version

+ var ErrContextIndexOutOfRange = errors.New("index out of range in context")

+ var ErrContextInvalidKeyType = errors.New("invalid key type for navigation")

+ var ErrContextKeyNotFound = errors.New("key not found in context")

+ var ErrFilterArgsInvalid = errors.New("filter arguments are invalid")

+ var ErrFilterInputEmpty = errors.New("filter input is empty")

+ var ErrFilterInputInvalid = errors.New("filter input is invalid")

+ var ErrFilterInputInvalidTimeFormat = errors.New("filter input has an invalid time format")

+ var ErrFilterInputNotNumeric = errors.New("filter input is not numeric")

+ var ErrFilterInputNotSlice = errors.New("filter input is not a slice")

+ var ErrFilterInputUnsupportedType = errors.New("filter input is of an unsupported type")

+ var ErrFilterNotFound = errors.New("filter not found")

+ var ErrInsufficientArgs = errors.New("insufficient arguments provided")

+ func ApplyFilters(value interface{}, fs []Filter, ctx Context) (interface{}, error)

+ func Execute(tpl *Template, ctx Context) (string, error)

+ func MustExecute(tpl *Template, ctx Context) string

+ func RegisterFilter(name string, fn FilterFunc) error

+ func Render(source string, ctx Context) (string, error)

+ type Context map[string]interface

+ func (c Context) Get(key string) (interface{}, error)

+ func (c Context) Set(key string, value interface{})

+ func NewContext() Context

+ type Filter struct

+ Args []FilterArg

+ Name string

+ type FilterArg interface

+ Type func() string

+ Value func() interface{}

+ type FilterFunc func(interface{}, ...string) (interface{}, error)

+ type Node struct

+ Children []*Node

+ Filters []Filter

+ Text string

+ Type string

+ Variable string

+ type NumberArg struct

+ func (a NumberArg) Type() string

+ func (a NumberArg) Value() interface{}

+ type Parser struct

+ func NewParser() *Parser

+ func (p *Parser) Parse(src string) (*Template, error)

+ type StringArg struct

+ func (a StringArg) Type() string

+ func (a StringArg) Value() interface{}

+ type Template struct

+ Nodes []*Node

+ func NewTemplate() *Template

+ func Parse(source string) (*Template, error)

+ func (t *Template) Execute(ctx Context) (string, error)

+ func (t *Template) MustExecute(ctx Context) string

+ type VariableArg struct

+ func (a VariableArg) Type() string

+ func (a VariableArg) Value() interface{}