template

package module

Go to main page

Versions in this module

v0

v0.3.5

Jan 19, 2026

v0.3.4

Dec 14, 2025

v0.3.3

Dec 14, 2025

v0.3.2

Dec 14, 2025

v0.3.1

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)

v0.3.0

Oct 6, 2025

v0.2.8

Sep 10, 2025

Changes in this version

+ type LoopContext struct

+ First bool

+ Index int

+ Last bool

+ Length int

+ Revindex int

v0.2.7

Aug 1, 2025

v0.2.6

Aug 1, 2025

v0.2.5

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

v0.2.4

Jun 9, 2025

v0.2.3

Jun 4, 2025

Changes in this version

type Value

+ Struct interface{}

type ValueType

+ const TypeNil

+ const TypeStruct

v0.2.2

May 24, 2025

v0.2.1

Apr 15, 2025

v0.2.0

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)

v0.1.0

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{}

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL