texpr

type CompileSource[CE any] interface {
	// Returns the initial compiled expression value. This is passed to the compiler functions for the
	// first expressions in a chain.
	GetInitial(e *Expr) (CE, error)
	// Returns a compiled value for a constant expression.
	GetConstantCompiled(e *Expr, root *Type, previous CE, arguments []CE) (CE, error)
	// Returns a compiler for a value expression.
	GetValueCompiler(e *Expr, root *Type, previous CE) (Compiler[CE], error)
}

type CompileSourceLookup[CE any] struct {
	// The initial compiled expression value. This is passed to the compiler functions for the
	// first expressions in a chain.
	Initial CE
	// Compilers for each type and their values.
	TypeCompilers TypeCompilers[CE]
	// A compiler for a constant expression.
	ConstantCompiler Compiler[CE]
}

type Compiler[CE any] func(e *Expr, root *Type, previous CE, arguments []CE) (CE, error)

type Expr struct {
	// The string parsed from the expression input.
	Token string
	// The start position of the expression in the input.
	Start Position
	// The end position of the expression in the input.
	End Position
	// If this expression is a constant value and not a value.
	Constant bool
	// The parsed value if this expression is a constant.
	Parsed any
	// The value this expression is in the parent type.
	Value *Value
	// The parent type if any. If prev is nil this represents the root type.
	ParentType *Type
	// The type of this value/constant.
	Type *Type
	// The arguments to pass as the parameters to the value.
	Arguments []*Expr
	// The next expression in the chain on the result of this one.
	Next *Expr
	// The previous expression in the chain or nil. When nil this is either a constant
	// or a value on the root type.
	Prev *Expr
	// The expression this is an argument for, which is only set on the first expression in a chain.
	Parent *Expr
	// The parameter this expression is on if any. This is only set for the first expression in the chain.
	Parameter *Parameter
	// The system that created the expression.
	System *System
}

type Options struct {
	// The type that is used as the root of the expressions.
	RootType TypeName
	// The expected types if any. If none are given then the type of the expression is returned.
	// If one or more are given then the expression is automatically cast to a desired type
	// if possible, otherwise errors if it can't meet the expected types.
	ExpectedTypes []TypeName
	// The expression to parse.
	Expression string
}

type Parameter struct {
	// The expected type for the parameter. Either this or Generic is required.
	Type TypeName `json:"type,omitempty"`
	// If there is no expected type, but this parameter and potentially others need to be the same type.
	// The generic parameters can also decide the type of generic value.
	Generic bool `json:"generic,omitempty"`
	// The name of the parameter.
	Name string `json:"name,omitempty"`
	// A more detailed description of the parameter.
	Description string `json:"description,omitempty"`
	// A default value, making this an optional parameter. This must be a valid value that can be parsed by the type.
	Default *string `json:"default,omitempty"`
	// contains filtered or unexported fields
}

type ParseError struct {
	Message   string
	Expr      *Expr
	Parameter *Parameter
	Start     *Position
	End       *Position
}

type Position struct {
	// The index of the character in Options.Expression
	Index int
	// The line of the character, where \n delimits lines.
	Line int
	// The column of the character in its line.
	Column int
}

type Reflect struct {
	// contains filtered or unexported fields
}

type ReflectCompiled func(root any) (any, error)

type ReflectConversion struct {
	Type        TypeName
	ConvertTo   func(v any) (any, error)
	ConvertFrom func(v any) (any, error)
}

type ReflectOptions struct {
	Conversions map[reflect.Type]ReflectConversion
	Types       map[reflect.Type]Type
}

type System struct {
	// contains filtered or unexported fields
}

type SystemError struct {
	Message   string
	Type      *Type
	Value     *Value
	Parameter *Parameter
	Path      *string
}

type Type struct {
	// The name of this type, should be unique.
	Name TypeName `json:"name"`
	// A description of this type.
	Description string `json:"description,omitempty"`
	// All values of this type.
	Values []Value `json:"values,omitempty"`
	// All types that this type can be converted to, and which value path can be used to do it.
	As map[TypeName]string `json:"as,omitempty"`
	// The type might be an enumerated value which means it has to be one of the specified values.
	// Parse can be specified to validate this and return a different data type other than string.
	Enums []string `json:"enums,omitempty"`
	// A custom parse function that converts a constant into a real value that is stored in Expression.Parsed.
	// If the given input does not match the type an error must be returned.
	Parse func(x string) (any, error) `json:"-"`
	// The parse order of the type. By default all types are considered equal and have an order of 0.
	// Higher parse orders are used first. For all types with the same parse order they are ordered
	// whether they have a Parse function (it prefers this). For two types with equivalent parse function
	// specificity they are ordered by type name length (preferring longer types before shorter).
	ParseOrder int `json:"parseOrder,omitempty"`
	// contains filtered or unexported fields
}

type TypeCompilers[CE any] map[TypeName]ValueCompilers[CE]

type TypeName string

type Value struct {
	// The main path for the value. Alternatives can be specified with Aliases.
	Path string `json:"path"`
	// The aliases to the path, to allow for more than one way to refer to the value.
	Aliases []string `json:"aliases,omitempty"`
	// The description of the value.
	Description string `json:"description,omitempty"`
	// The type of the value.
	Type TypeName `json:"type,omitempty"`
	// If the value is has a generic type that's determined based on one or more generic parameters.
	Generic bool `json:"generic,omitempty"`
	// The parameters for the value.
	Parameters []Parameter `json:"parameters,omitempty"`
	// If the last parameter can be specified any number of times.
	Variadic bool `json:"variadic,omitempty"`
	// contains filtered or unexported fields
}

type ValueCompilers[CE any] map[string]Compiler[CE]