object

package

Go to main page

Versions in this module

v0

v0.3.0

Jul 26, 2025

Changes in this version

type BoolValue

+ func (b *BoolValue) Clone() *BoolValue

+ type FunctionBuilder struct

+ func NewFunctionBuilder(name string) *FunctionBuilder

+ func (fb *FunctionBuilder) Build() *FunctionType

+ func (fb *FunctionBuilder) WithBody(body *ast.FuncDecl) *FunctionBuilder

+ func (fb *FunctionBuilder) WithBuiltin(builtin BuiltinFunction) *FunctionBuilder

+ func (fb *FunctionBuilder) WithOptionalParameter(name string, typ Type, defaultValue Value) *FunctionBuilder

+ func (fb *FunctionBuilder) WithParameter(name string, typ Type) *FunctionBuilder

+ func (fb *FunctionBuilder) WithReturnType(returnType Type) *FunctionBuilder

+ func (fb *FunctionBuilder) WithVariadicParameter(name string, typ Type) *FunctionBuilder

type FunctionType

+ func (ft *FunctionType) AppendSignatures(sigs []*FunctionSignature)

+ func (ft *FunctionType) Signatures() []*FunctionSignature

type NumberValue

+ func (n *NumberValue) Clone() *NumberValue

type Parameter

+ func NewOptionalParameter(name string, typ Type, defaultValue Value) *Parameter

+ func NewParameter(name string, typ Type) *Parameter

+ func NewVariadicParameter(name string, typ Type) *Parameter

type StringValue

+ func (s *StringValue) Clone() *StringValue

type Type

+ func GetAnyType() Type

+ func GetBoolType() Type

+ func GetErrorType() Type

+ func GetNeverType() Type

+ func GetNullType() Type

+ func GetNumberType() Type

+ func GetStringType() Type

+ func GetVoidType() Type

v0.2.0

Jul 19, 2025

v0.1.0

Jul 11, 2025

Changes in this version

+ var BoolConstraint = NewInterfaceConstraint(boolType)

+ var ComparableConstraint = NewCompositeConstraint(NewOperatorConstraint(OpEqual, anyType, boolType), ...)

+ var FALSE = &BoolValue

+ var GlobalDecoratorRegistry = NewDecoratorRegistry()

+ var GlobalTraitRegistry = NewTraitRegistry()

+ var NULL = &NullValue

+ var NumericConstraint = NewInterfaceConstraint(numberType)

+ var SerializableConstraint = NewInterfaceConstraint(anyType)

+ var StringConstraint = NewInterfaceConstraint(stringType)

+ var TRUE = &BoolValue

+ func Entries(t Type) (map[string]Type, error)

+ func ExampleAdvancedConstraintCombination()

+ func ExampleCompositeConstraint()

+ func ExampleConstrainedGeneric()

+ func ExampleConstraintIntegration()

+ func ExampleEnumUsage()

+ func ExampleGenericTraitConstraintInheritance()

+ func ExampleServiceTrait()

+ func ExampleStaticMethodsAndInheritance()

+ func ExampleTraitGenericInheritanceIntegration()

+ func ExampleUnionConstraint()

+ func ImplementsTrait(t Type, traitName string) bool

+ func Keys(t Type) ([]string, error)

+ type ASTConverter struct

+ func (c *ASTConverter) ConvertField(field *ast.Field) (*Field, error)

+ func (c *ASTConverter) ConvertModifiers(modifiers []ast.Modifier) []FieldModifier

+ func (c *ASTConverter) ConvertParameter(param *ast.Parameter) (*Parameter, error)

+ func (c *ASTConverter) ConvertType(node ast.Node) (Type, error)

+ func (c *ASTConverter) ConvertValue(node ast.Node) (Value, error)

+ type ArrayPattern struct

+ ArrayType Type

+ Elements []PatternMatch

+ func (ap *ArrayPattern) Match(value Value) bool

+ type ArrayType struct

+ func NewArrayType(elementType Type) *ArrayType

+ func (a *ArrayType) AssignableTo(t Type) bool

+ func (a *ArrayType) ConvertibleTo(t Type) bool

+ func (a *ArrayType) ElementType() Type

+ func (a *ArrayType) Implements(t Type) bool

+ type ArrayValue struct

+ Elements []Value

+ func NewArrayValue(elementType Type, elements ...Value) *ArrayValue

+ func (a *ArrayValue) Append(value Value)

+ func (a *ArrayValue) Get(index int) Value

+ func (a *ArrayValue) Interface() any

+ func (a *ArrayValue) Length() int

+ func (a *ArrayValue) Set(index int, value Value)

+ func (a *ArrayValue) Text() string

+ func (a *ArrayValue) Type() Type

+ type BoolType struct

+ func NewBoolType() *BoolType

+ type BoolValue struct

+ Value bool

+ func (b *BoolValue) Interface() any

+ func (b *BoolValue) Text() string

+ func (b *BoolValue) Type() Type

+ type BuiltinFunction func(args ...Value) Value

+ type ClassConstructor struct

+ func NewClassConstructor(name string, clsType *ClassType, signature []Type, isNamed bool) *ClassConstructor

+ func NewDefaultConstructor(clsType *ClassType) *ClassConstructor

+ func (cc *ClassConstructor) Call(args ...Value) Value

+ func (cc *ClassConstructor) In(i int) Type

+ func (cc *ClassConstructor) IsNamed() bool

+ func (cc *ClassConstructor) Match(args []Value) bool

+ func (cc *ClassConstructor) Name() string

+ func (cc *ClassConstructor) NumIn() int

+ func (cc *ClassConstructor) Signature() []Type

+ type ClassInstance struct

+ func (ci *ClassInstance) CallMethod(name string, args []Value, namedArgs map[string]Value) (Value, error)

+ func (ci *ClassInstance) GetField(name string) Value

+ func (ci *ClassInstance) GetMethod(name string) Method

+ func (ci *ClassInstance) Interface() any

+ func (ci *ClassInstance) SetField(name string, value Value)

+ func (ci *ClassInstance) Text() string

+ func (ci *ClassInstance) Type() Type

+ type ClassType struct

+ func ConvertClassDecl(decl *ast.ClassDecl) *ClassType

+ func NewClassType(name string) *ClassType

+ func NewGenericClass(name string, typeParams []string, constraints map[string]Constraint) *ClassType

+ func (ct *ClassType) AddCompositeConstraint(typeParam string, constraints ...Constraint)

+ func (ct *ClassType) AddConstraint(typeParam string, constraint Constraint)

+ func (ct *ClassType) AddConstructor(ctor Constructor)

+ func (ct *ClassType) AddField(name string, filed *Field)

+ func (ct *ClassType) AddInterface(iface *TraitType)

+ func (ct *ClassType) AddOperator(op Operator, fn *FunctionType)

+ func (ct *ClassType) AddOperatorConstraint(typeParam string, op Operator, rightType, returnType Type)

+ func (ct *ClassType) AddStaticField(name string, field *Field)

+ func (ct *ClassType) AddStaticMethod(name string, method *FunctionType)

+ func (ct *ClassType) AddTraitConstraint(typeParam string, trait *TraitType)

+ func (ct *ClassType) AddTypeConstraint(typeParam string, targetType Type)

+ func (ct *ClassType) AddUnionConstraint(typeParam string, constraints ...Constraint)

+ func (ct *ClassType) CheckConstraints(typeArgs []Type) error

+ func (ct *ClassType) CheckTraitConstraints(typeArgs []Type) error

+ func (ct *ClassType) FieldByName(name string) Type

+ func (ct *ClassType) GetConstraint(typeParam string) Constraint

+ func (ct *ClassType) GetConstructorByName(name string) Constructor

+ func (ct *ClassType) GetConstructors() []Constructor

+ func (ct *ClassType) GetInterfaces() []*TraitType

+ func (ct *ClassType) GetOverriddenMethod(name string) *FunctionType

+ func (ct *ClassType) GetParent() *ClassType

+ func (ct *ClassType) GetStaticField(name string) *Field

+ func (ct *ClassType) GetStaticMethod(name string) *FunctionType

+ func (ct *ClassType) GetStaticValue(name string) Value

+ func (ct *ClassType) GetTraitConstraints(typeParam string) []*TraitType

+ func (ct *ClassType) HasConstraint(typeParam string) bool

+ func (ct *ClassType) Implements(t Type) bool

+ func (ct *ClassType) ImplementsTrait(iface *TraitType) bool

+ func (ct *ClassType) Instantiate(typeArgs []Type) (*ClassType, error)

+ func (ct *ClassType) InstantiateWithTraitConstraints(typeArgs []Type) (*ClassType, error)

+ func (ct *ClassType) IsSubclassOf(parentType *ClassType) bool

+ func (ct *ClassType) MethodByName(name string) Method

+ func (ct *ClassType) New(values ...Value) Value

+ func (ct *ClassType) OverrideMethod(name string, method *FunctionType)

+ func (ct *ClassType) SetParent(parent *ClassType)

+ func (ct *ClassType) SetStaticValue(name string, value Value)

+ type CompositeConstraint struct

+ func NewCompositeConstraint(constraints ...Constraint) *CompositeConstraint

+ func TypesToCompositeConstraint(types ...Type) *CompositeConstraint

+ func (cc *CompositeConstraint) SatisfiedBy(t Type) bool

+ func (cc *CompositeConstraint) String() string

+ type ConstrainedGenericClass struct

+ func NewConstrainedGenericClass(name string, typeParams []string, constraints map[string]Constraint) *ConstrainedGenericClass

+ func (cgc *ConstrainedGenericClass) Instantiate(typeArgs []Type) (*ClassType, error)

+ type Constraint interface

+ SatisfiedBy func(Type) bool

+ String func() string

+ func TypeToConstraint(t Type) Constraint

+ type Constructor interface

+ IsNamed func() bool

+ Name func() string

+ type ConstructorPattern struct

+ Arguments []PatternMatch

+ ConstructorName string

+ ConstructorType Type

+ func (cp *ConstructorPattern) Match(value Value) bool

+ type Converter interface

+ ConvertField func(field *ast.Field) (*Field, error)

+ ConvertModifiers func(modifiers []ast.Modifier) []FieldModifier

+ ConvertParameter func(param *ast.Parameter) (*Parameter, error)

+ ConvertType func(node ast.Node) (Type, error)

+ ConvertValue func(node ast.Node) (Value, error)

+ type DecoratorProcessor interface

+ Process func(target any, args []Value) (any, error)

+ type DecoratorRegistry struct

+ func NewDecoratorRegistry() *DecoratorRegistry

+ func (dr *DecoratorRegistry) GetDecorator(name string) *DecoratorType

+ func (dr *DecoratorRegistry) RegisterDecorator(decorator *DecoratorType)

+ type DecoratorTarget int

+ const DecoratorTargetClass

+ const DecoratorTargetEnum

+ const DecoratorTargetField

+ const DecoratorTargetFunction

+ const DecoratorTargetMethod

+ const DecoratorTargetParameter

+ const DecoratorTargetTrait

+ type DecoratorType struct

+ func NewDecoratorType(name string, target DecoratorTarget, processor DecoratorProcessor) *DecoratorType

+ func (d *DecoratorType) Process(target any, args []Value) (any, error)

+ func (d *DecoratorType) Target() DecoratorTarget

+ type DefaultTypeInference struct

+ func (ti *DefaultTypeInference) CheckConstraintSatisfaction(t Type, constraint Constraint) bool

+ func (ti *DefaultTypeInference) InferBidirectional(target Type, source Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromAssignment(targetType Type, sourceType Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromBinaryOp(op Operator, left, right Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromCall(funcType Type, args []Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromConstraints(constraints map[string]Constraint) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromContext(context *TypeContext) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromExpression(expr *ExpressionContext) map[string]Type

+ func (ti *DefaultTypeInference) InferFromIndexOp(container, index Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromLiteral(literal Value) Type

+ func (ti *DefaultTypeInference) InferFromOverload(overloads []*FunctionType, args []Value) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromPattern(pattern PatternMatch) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromUnaryOp(op Operator, operand Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferFromUsage(usage *TypeUsage) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferRecursive(types []Type) (map[string]Type, error)

+ func (ti *DefaultTypeInference) InferTypeArgs(concreteType Type, genericType Type) ([]Type, error)

+ func (ti *DefaultTypeInference) InferWithContext(target Type, context *TypeContext) (map[string]Type, error)

+ func (ti *DefaultTypeInference) PropagateConstraints(constraints map[string]Constraint, unifier map[string]Type) (map[string]Constraint, error)

+ func (ti *DefaultTypeInference) SolveConstraints(constraints map[string]Constraint) (map[string]Type, error)

+ func (ti *DefaultTypeInference) SubstituteTypes(t Type, substitutions map[string]Type) Type

+ func (ti *DefaultTypeInference) UnifyTypes(t1, t2 Type) (map[string]Type, error)

+ type DefaultTypeUtils struct

+ func (tu *DefaultTypeUtils) DeepMutable(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) DeepPartial(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) DeepReadonly(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) DeepRequired(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) Entries(t Type) (map[string]Type, error)

+ func (tu *DefaultTypeUtils) Exclude(unionType, excludeType Type) (Type, error)

+ func (tu *DefaultTypeUtils) Extract(unionType, extractType Type) (Type, error)

+ func (tu *DefaultTypeUtils) Filter(t Type, predicate func(Type) bool) (Type, error)

+ func (tu *DefaultTypeUtils) If(condition bool, trueType, falseType Type) Type

+ func (tu *DefaultTypeUtils) Infer(template Type, constraints map[string]Type) (Type, error)

+ func (tu *DefaultTypeUtils) Intersect(t1, t2 Type) (Type, error)

+ func (tu *DefaultTypeUtils) Keys(t Type) ([]string, error)

+ func (tu *DefaultTypeUtils) Map(t Type, mapper func(Type) Type) (Type, error)

+ func (tu *DefaultTypeUtils) Merge(t1, t2 Type) (Type, error)

+ func (tu *DefaultTypeUtils) Mutable(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) NonNullable(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) Omit(t Type, keys ...string) (Type, error)

+ func (tu *DefaultTypeUtils) Optional(t Type) Type

+ func (tu *DefaultTypeUtils) Partial(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) Pick(t Type, keys ...string) (Type, error)

+ func (tu *DefaultTypeUtils) Readonly(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) Record(keyType, valueType Type) Type

+ func (tu *DefaultTypeUtils) Required(t Type) (Type, error)

+ func (tu *DefaultTypeUtils) Union(types ...Type) Type

+ func (tu *DefaultTypeUtils) Values(t Type) ([]Type, error)

+ type EnumType struct

+ func NewADTEnum(name string, variants map[string]map[string]Type) *EnumType

+ func NewAssociatedEnum(name string, fields map[string]*Field, valueMap map[string]Value) *EnumType

+ func NewEnumType(name string) *EnumType

+ func NewExplicitNumericEnum(name string, valueMap map[string]int) *EnumType

+ func NewMixedEnum(name string, valueMap map[string]Value) *EnumType

+ func NewNumericEnum(name string, valueNames []string) *EnumType

+ func NewStringEnum(name string, valueMap map[string]string) *EnumType

+ func (e *EnumType) AddField(name string, field *Field)

+ func (e *EnumType) AddVariant(variant *EnumVariant)

+ func (e *EnumType) AssignableTo(u Type) bool

+ func (e *EnumType) ConvertibleTo(u Type) bool

+ func (e *EnumType) GetValue(name string) *EnumVariant

+ func (e *EnumType) GetValues() []*EnumVariant

+ func (e *EnumType) GetVariant(name string) *EnumVariant

+ func (e *EnumType) GetVariants() []*EnumVariant

+ func (e *EnumType) Implements(u Type) bool

+ func (e *EnumType) IsADT() bool

+ func (e *EnumType) Kind() ObjKind

+ func (e *EnumType) Name() string

+ func (e *EnumType) SetADT(discriminant string)

+ func (e *EnumType) Text() string

+ type EnumVariant struct

+ func NewEnumVariant(name string, value Value) *EnumVariant

+ func (ev *EnumVariant) AddADTFieldType(name string, fieldType Type)

+ func (ev *EnumVariant) GetADTField(name string) Value

+ func (ev *EnumVariant) GetField(name string) Value

+ func (ev *EnumVariant) Interface() any

+ func (ev *EnumVariant) Name() string

+ func (ev *EnumVariant) SetADTField(name string, value Value)

+ func (ev *EnumVariant) SetField(name string, value Value)

+ func (ev *EnumVariant) Text() string

+ func (ev *EnumVariant) Type() Type

+ func (ev *EnumVariant) Value() Value

+ type ErrorType struct

+ func NewErrorType() *ErrorType

+ type ErrorValue struct

+ Value string

+ func (e *ErrorValue) Interface() any

+ func (e *ErrorValue) Text() string

+ func (e *ErrorValue) Type() Type

+ type ExpressionContext struct

+ Expression string

+ Type Type

+ type Field struct

+ func (f *Field) AddModifier(mod FieldModifier) *Field

+ func (f *Field) GetDefaultValue() Value

+ func (f *Field) HasDefaultValue() bool

+ func (f *Field) HasModifier(mod FieldModifier) bool

+ func (f *Field) IsRequired() bool

+ func (f *Field) SetDefaultValue(value Value)

+ type FieldModifier int

+ const FieldModifierNone

+ const FieldModifierOptional

+ const FieldModifierPub

+ const FieldModifierReadonly

+ const FieldModifierRequired

+ const FieldModifierStatic

+ func (i FieldModifier) String() string

+ type Function interface

+ Call func(args ...Value) Value

+ In func(i int) Type

+ Match func(args []Value) bool

+ NumIn func() int

+ Signature func() []Type

+ type FunctionCallContext struct

+ Arguments []Type

+ FunctionName string

+ ReturnType Type

+ type FunctionSignature struct

+ type FunctionType struct

+ func NewGenericFunction(name string, typeParams []string, constraints map[string]Constraint) *FunctionType

+ func (ft *FunctionType) AssignableTo(t Type) bool

+ func (ft *FunctionType) Call(args []Value, namedArgs map[string]Value, evaluator ...core.FunctionEvaluator) (Value, error)

+ func (ft *FunctionType) ConvertibleTo(t Type) bool

+ func (ft *FunctionType) Implements(t Type) bool

+ func (ft *FunctionType) Kind() ObjKind

+ func (ft *FunctionType) MatchSignature(args []Value, namedArgs map[string]Value) (*FunctionSignature, error)

+ func (ft *FunctionType) Name() string

+ func (ft *FunctionType) Text() string

+ type FunctionValue struct

+ func NewFunctionValue(functionType *FunctionType) *FunctionValue

+ func (f *FunctionValue) Call(args []Value, namedArgs map[string]Value) (Value, error)

+ func (f *FunctionValue) Interface() any

+ func (f *FunctionValue) Text() string

+ func (f *FunctionValue) Type() Type

+ type Generic interface

+ CheckConstraints func(typeArgs []Type) error

+ Constraints func() map[string]Constraint

+ Instantiate func(typeArgs []Type) (Type, error)

+ IsGeneric func() bool

+ TypeParameters func() []string

+ type GenericBase struct

+ func NewGenericBase(typeParams []string, constraints map[string]Constraint) *GenericBase

+ func (gb *GenericBase) CheckConstraints(typeArgs []Type) error

+ func (gb *GenericBase) Constraints() map[string]Constraint

+ func (gb *GenericBase) IsGeneric() bool

+ func (gb *GenericBase) TypeParameters() []string

+ type InterfaceConstraint struct

+ func NewInterfaceConstraint(interfaceType Type) *InterfaceConstraint

+ func NewTypeConstraint(targetType Type) *InterfaceConstraint

+ func (ic *InterfaceConstraint) SatisfiedBy(t Type) bool

+ func (ic *InterfaceConstraint) String() string

+ type IntersectionType struct

+ func NewIntersectionType(types ...Type) *IntersectionType

+ func (i *IntersectionType) AssignableTo(t Type) bool

+ func (i *IntersectionType) ConvertibleTo(t Type) bool

+ func (i *IntersectionType) Implements(t Type) bool

+ func (i *IntersectionType) Kind() ObjKind

+ func (i *IntersectionType) Name() string

+ func (i *IntersectionType) New(values ...Value) Value

+ func (i *IntersectionType) Text() string

+ type KeyValuePair struct

+ Key Value

+ Value Value

+ type MapType struct

+ func NewMapType(keyType, valueType Type) *MapType

+ func (m *MapType) AssignableTo(t Type) bool

+ func (m *MapType) ConvertibleTo(t Type) bool

+ func (m *MapType) Implements(t Type) bool

+ func (m *MapType) KeyType() Type

+ func (m *MapType) ValueType() Type

+ type MapValue struct

+ Pairs []*KeyValuePair

+ func NewMapValue(keyType, valueType Type) *MapValue

+ func (m *MapValue) Clear()

+ func (m *MapValue) Delete(key Value)

+ func (m *MapValue) Get(key Value) Value

+ func (m *MapValue) Has(key Value) bool

+ func (m *MapValue) Interface() any

+ func (m *MapValue) Keys() []Value

+ func (m *MapValue) Length() int

+ func (m *MapValue) Set(key, value Value)

+ func (m *MapValue) Text() string

+ func (m *MapValue) Type() Type

+ func (m *MapValue) Values() []Value

+ type Method interface

+ Call func(args []Value, namedArgs map[string]Value, evaluator ...core.FunctionEvaluator) (Value, error)

+ type NullValue struct

+ func (n *NullValue) Interface() any

+ func (n *NullValue) Text() string

+ func (n *NullValue) Type() Type

+ type NullableType struct

+ func NewNullableType(baseType Type) *NullableType

+ func (n *NullableType) AssignableTo(t Type) bool

+ func (n *NullableType) BaseType() Type

+ func (n *NullableType) ConvertibleTo(t Type) bool

+ func (n *NullableType) Implements(t Type) bool

+ func (n *NullableType) Kind() ObjKind

+ func (n *NullableType) Name() string

+ func (n *NullableType) New(values ...Value) Value

+ func (n *NullableType) Text() string

+ type NumberType struct

+ func NewNumberType() *NumberType

+ type NumberValue struct

+ Value *big.Float

+ func NewNumberValue(value string) *NumberValue

+ func (n *NumberValue) Interface() any

+ func (n *NumberValue) Text() string

+ func (n *NumberValue) Type() Type

+ type ObjKind int

+ const O_ANY

+ const O_ARR

+ const O_BOOL

+ const O_BUILTIN

+ const O_CLASS

+ const O_DECORATOR

+ const O_ENUM

+ const O_ERROR

+ const O_FUNC

+ const O_INTERSECTION

+ const O_LITERAL

+ const O_MAP

+ const O_NEVER

+ const O_NULL

+ const O_NULLABLE

+ const O_NUM

+ const O_OBJ

+ const O_QUOTE

+ const O_RET

+ const O_SET

+ const O_STR

+ const O_SYMBOL

+ const O_TRAIT

+ const O_TUPLE

+ const O_TYPE_PARAM

+ const O_UNION

+ const O_VOID

+ func (i ObjKind) String() string

+ func (o ObjKind) Equal(x ObjKind) bool

+ type Object interface

+ Field func(i int) Type

+ FieldByName func(name string) Type

+ Method func(i int) Method

+ MethodByName func(name string) Method

+ NumField func() int

+ NumMethod func() int

+ type ObjectType struct

+ func NewObjectType(name string, kind ObjKind) *ObjectType

+ func (o *ObjectType) AddField(name string, field *Field)

+ func (o *ObjectType) AddMethod(name string, signature Method)

+ func (t *ObjectType) AssignableTo(u Type) bool

+ func (t *ObjectType) ConvertibleTo(u Type) bool

+ func (t *ObjectType) Field(i int) Type

+ func (t *ObjectType) FieldByName(name string) Type

+ func (t *ObjectType) Implements(u Type) bool

+ func (t *ObjectType) Kind() ObjKind

+ func (t *ObjectType) Method(i int) Method

+ func (t *ObjectType) MethodByName(name string) Method

+ func (t *ObjectType) Name() string

+ func (t *ObjectType) New(values ...Value) Value

+ func (t *ObjectType) NumField() int

+ func (t *ObjectType) NumMethod() int

+ func (t *ObjectType) Text() string

+ type Operator int

+ const OpA

+ const OpAdd

+ const OpAnd

+ const OpAssign

+ const OpB

+ const OpC

+ const OpCall

+ const OpConcat

+ const OpD

+ const OpDiv

+ const OpE

+ const OpEqual

+ const OpF

+ const OpG

+ const OpGreater

+ const OpGreaterEqual

+ const OpH

+ const OpI

+ const OpIllegal

+ const OpIndex

+ const OpJ

+ const OpK

+ const OpL

+ const OpLess

+ const OpLessEqual

+ const OpM

+ const OpMod

+ const OpMul

+ const OpN

+ const OpNot

+ const OpO

+ const OpOr

+ const OpP

+ const OpQ

+ const OpR

+ const OpS

+ const OpSub

+ const OpT

+ const OpU

+ const OpV

+ const OpW

+ const OpX

+ const OpY

+ const OpZ

+ const Opa

+ const Opb

+ const Opc

+ const Opd

+ const Ope

+ const Opf

+ const Opg

+ const Oph

+ const Opi

+ const Opj

+ const Opk

+ const Opl

+ const Opm

+ const Opn

+ const Opo

+ const Opp

+ const Opq

+ const Opr

+ const Ops

+ const Opu

+ const Opv

+ const Opw

+ const Opz

+ const Ott

+ func (i Operator) String() string

+ type OperatorConstraint struct

+ func NewOperatorConstraint(op Operator, rightType, returnType Type) *OperatorConstraint

+ func NewOperatorConstraintSimple(op Operator) *OperatorConstraint

+ func (oc *OperatorConstraint) SatisfiedBy(t Type) bool

+ func (oc *OperatorConstraint) String() string

+ type OperatorOverload struct

+ type Parameter struct

+ type PatternMatch interface

+ Match func(value Value) bool

+ type PrimitiveType struct

+ func NewPrimitiveType(name string, kind ObjKind) *PrimitiveType

+ func (pt *PrimitiveType) AssignableTo(u Type) bool

+ func (pt *PrimitiveType) ConvertibleTo(u Type) bool

+ func (pt *PrimitiveType) Implements(u Type) bool

+ func (pt *PrimitiveType) Kind() ObjKind

+ func (pt *PrimitiveType) Name() string

+ func (pt *PrimitiveType) Text() string

+ type Registry struct

+ func NewRegistry() *Registry

+ func (r *Registry) LookupFunction(name string) (*FunctionType, bool)

+ func (r *Registry) LookupOperator(op Operator, left, right Value) (*OperatorOverload, error)

+ func (r *Registry) RegisterFunction(name string, signature *FunctionSignature) error

+ func (r *Registry) RegisterOperator(op Operator, left, right, returnType Type, fn *FunctionType)

+ type SetType struct

+ func NewSetType(elementType Type) *SetType

+ func (s *SetType) AssignableTo(u Type) bool

+ func (s *SetType) ConvertibleTo(u Type) bool

+ func (s *SetType) ElementType() Type

+ func (s *SetType) Implements(u Type) bool

+ func (s *SetType) Kind() ObjKind

+ func (s *SetType) Name() string

+ func (s *SetType) Text() string

+ type SetValue struct

+ func NewSetValue(setType *SetType, elements ...Value) *SetValue

+ func (sv *SetValue) Add(element Value) error

+ func (sv *SetValue) Clear()

+ func (sv *SetValue) Contains(element Value) (bool, error)

+ func (sv *SetValue) Difference(other *SetValue) (*SetValue, error)

+ func (sv *SetValue) Elements() map[string]Value

+ func (sv *SetValue) Has(element Value) bool

+ func (sv *SetValue) Interface() any

+ func (sv *SetValue) Intersect(other *SetValue) (*SetValue, error)

+ func (sv *SetValue) IsEmpty() bool

+ func (sv *SetValue) Length() int

+ func (sv *SetValue) Remove(element Value) error

+ func (sv *SetValue) Text() string

+ func (sv *SetValue) ToArray() *ArrayValue

+ func (sv *SetValue) Type() Type

+ func (sv *SetValue) Union(other *SetValue) (*SetValue, error)

+ type SourceLocation interface

+ Col func() int

+ File func() string

+ Line func() int

+ type StringType struct

+ func NewStringType() *StringType

+ type StringValue struct

+ Value string

+ func (s *StringValue) Interface() any

+ func (s *StringValue) Text() string

+ func (s *StringValue) Type() Type

+ type TraitImpl struct

+ func ConvertImplDecl(decl *ast.ImplDecl) *TraitImpl

+ func NewTraitImpl(trait *TraitType, implType Type) *TraitImpl

+ func (ti *TraitImpl) AddField(name string, field *Field)

+ func (ti *TraitImpl) AddMethod(name string, method *FunctionType)

+ func (ti *TraitImpl) AddOperator(op Operator, fn *FunctionType)

+ func (ti *TraitImpl) GetMethod(name string) *FunctionType

+ type TraitRegistry struct

+ func NewTraitRegistry() *TraitRegistry

+ func (tr *TraitRegistry) GetImpl(traitName, typeName string) []*TraitImpl

+ func (tr *TraitRegistry) GetTrait(name string) *TraitType

+ func (tr *TraitRegistry) RegisterImpl(impl *TraitImpl)

+ func (tr *TraitRegistry) RegisterTrait(trait *TraitType)

+ type TraitType struct

+ func ConvertTraitDecl(decl *ast.TraitDecl) *TraitType

+ func NewTraitType(name string) *TraitType

+ func (t *TraitType) AddDefaultImpl(name string, impl *FunctionType)

+ func (t *TraitType) AddField(name string, field *Field)

+ func (t *TraitType) AddMethod(name string, method *FunctionType)

+ func (t *TraitType) AddOperator(op Operator, fn *FunctionType)

+ func (t *TraitType) AssignableTo(u Type) bool

+ func (t *TraitType) ConvertibleTo(u Type) bool

+ func (t *TraitType) GetDefaultImpl(name string) *FunctionType

+ func (t *TraitType) Implements(u Type) bool

+ func (t *TraitType) Kind() ObjKind

+ func (t *TraitType) Name() string

+ func (t *TraitType) Text() string

+ type TuplePattern struct

+ Elements []PatternMatch

+ TupleType *TupleType

+ func (tp *TuplePattern) Match(value Value) bool

+ type TupleType struct

+ func NewNamedTupleType(fieldNames []string, elementTypes []Type) *TupleType

+ func NewNamedTupleTypeWithMethods(fieldNames []string, elementTypes []Type) *TupleType

+ func NewTupleType(elementTypes ...Type) *TupleType

+ func NewTupleTypeWithMethods(elementTypes ...Type) *TupleType

+ func (t *TupleType) AssignableTo(u Type) bool

+ func (t *TupleType) ConvertibleTo(u Type) bool

+ func (t *TupleType) ElementTypes() []Type

+ func (t *TupleType) FieldNames() []string

+ func (t *TupleType) GetElementType(index int) Type

+ func (t *TupleType) GetFieldIndex(fieldName string) int

+ func (t *TupleType) Implements(u Type) bool

+ func (t *TupleType) Kind() ObjKind

+ func (t *TupleType) Length() int

+ func (t *TupleType) Name() string

+ func (t *TupleType) Text() string

+ type TupleValue struct

+ func NewTupleValue(tupleType *TupleType, elements ...Value) *TupleValue

+ func (tv *TupleValue) Destructure() []Value

+ func (tv *TupleValue) Elements() []Value

+ func (tv *TupleValue) Get(index int) Value

+ func (tv *TupleValue) GetByName(fieldName string) Value

+ func (tv *TupleValue) Interface() any

+ func (tv *TupleValue) Length() int

+ func (tv *TupleValue) Set(index int, value Value) error

+ func (tv *TupleValue) Text() string

+ func (tv *TupleValue) Type() Type

+ func (tv *TupleValue) With(index int, value Value) (*TupleValue, error)

+ type Type interface

+ AssignableTo func(u Type) bool

+ ConvertibleTo func(u Type) bool

+ Implements func(u Type) bool

+ Kind func() ObjKind

+ Name func() string

+ Text func() string

+ func DeepMutable(t Type) (Type, error)

+ func DeepPartial(t Type) (Type, error)

+ func DeepReadonly(t Type) (Type, error)

+ func DeepRequired(t Type) (Type, error)

+ func Exclude(unionType, excludeType Type) (Type, error)

+ func Extract(unionType, extractType Type) (Type, error)

+ func Filter(t Type, predicate func(Type) bool) (Type, error)

+ func If(condition bool, trueType, falseType Type) Type

+ func Infer(template Type, constraints map[string]Type) (Type, error)

+ func Intersect(t1, t2 Type) (Type, error)

+ func Map(t Type, mapper func(Type) Type) (Type, error)

+ func Merge(t1, t2 Type) (Type, error)

+ func Mutable(t Type) (Type, error)

+ func NonNullable(t Type) (Type, error)

+ func Omit(t Type, keys ...string) (Type, error)

+ func Optional(t Type) Type

+ func Partial(t Type) (Type, error)

+ func Pick(t Type, keys ...string) (Type, error)

+ func Readonly(t Type) (Type, error)

+ func Record(keyType, valueType Type) Type

+ func Required(t Type) (Type, error)

+ func Union(types ...Type) Type

+ func Values(t Type) ([]Type, error)

+ type TypeContext struct

+ Constraints map[string]Constraint

+ Expressions []*ExpressionContext

+ FunctionCalls []*FunctionCallContext

+ Hints map[string]Type

+ Variables map[string]Type

+ type TypeInference interface

+ CheckConstraintSatisfaction func(t Type, constraint Constraint) bool

+ InferBidirectional func(target Type, source Type) (map[string]Type, error)

+ InferFromAssignment func(targetType Type, sourceType Type) (map[string]Type, error)

+ InferFromBinaryOp func(op Operator, left, right Type) (map[string]Type, error)

+ InferFromCall func(funcType Type, args []Type) (map[string]Type, error)

+ InferFromConstraints func(constraints map[string]Constraint) (map[string]Type, error)

+ InferFromContext func(context *TypeContext) (map[string]Type, error)

+ InferFromExpression func(expr *ExpressionContext) map[string]Type

+ InferFromIndexOp func(container, index Type) (map[string]Type, error)

+ InferFromLiteral func(literal Value) Type

+ InferFromOverload func(overloads []*FunctionType, args []Value) (map[string]Type, error)

+ InferFromPattern func(pattern PatternMatch) (map[string]Type, error)

+ InferFromUnaryOp func(op Operator, operand Type) (map[string]Type, error)

+ InferFromUsage func(usage *TypeUsage) (map[string]Type, error)

+ InferRecursive func(types []Type) (map[string]Type, error)

+ InferTypeArgs func(concreteType Type, genericType Type) ([]Type, error)

+ InferWithContext func(target Type, context *TypeContext) (map[string]Type, error)

+ PropagateConstraints func(constraints map[string]Constraint, unifier map[string]Type) (map[string]Constraint, error)

+ SolveConstraints func(constraints map[string]Constraint) (map[string]Type, error)

+ SubstituteTypes func(t Type, substitutions map[string]Type) Type

+ UnifyTypes func(t1, t2 Type) (map[string]Type, error)

+ func NewTypeInference() TypeInference

+ type TypeOperator interface

+ Intersect func(other Type) (Type, error)

+ Unify func(other Type) (Type, error)

+ Union func(other Type) Type

+ type TypeParameter struct

+ func NewTypeParameter(name string, constraints map[string]Constraint) *TypeParameter

+ func (tp *TypeParameter) AssignableTo(u Type) bool

+ func (tp *TypeParameter) ConvertibleTo(u Type) bool

+ func (tp *TypeParameter) Implements(u Type) bool

+ func (tp *TypeParameter) Kind() ObjKind

+ func (tp *TypeParameter) Name() string

+ func (tp *TypeParameter) SatisfiesConstraint(constraint Constraint) bool

+ func (tp *TypeParameter) Text() string

+ type TypeRelation interface

+ IsAssignableTo func(u Type) bool

+ IsCompatibleWith func(u Type) bool

+ IsSubtypeOf func(u Type) bool

+ IsSupertypeOf func(u Type) bool

+ type TypeSubstituter interface

+ SubstituteType func(t Type, typeMap map[string]Type) Type

+ type TypeUsage struct

+ Arguments []Type

+ Constraints map[string]Constraint

+ Context string

+ Hints map[string]Type

+ ReturnType Type

+ type TypeUtils interface

+ DeepMutable func(t Type) (Type, error)

+ DeepPartial func(t Type) (Type, error)

+ DeepReadonly func(t Type) (Type, error)

+ DeepRequired func(t Type) (Type, error)

+ Entries func(t Type) (map[string]Type, error)

+ Exclude func(unionType, excludeType Type) (Type, error)

+ Extract func(unionType, extractType Type) (Type, error)

+ Filter func(t Type, predicate func(Type) bool) (Type, error)

+ If func(condition bool, trueType, falseType Type) Type

+ Infer func(template Type, constraints map[string]Type) (Type, error)

+ Intersect func(t1, t2 Type) (Type, error)

+ Keys func(t Type) ([]string, error)

+ Map func(t Type, mapper func(Type) Type) (Type, error)

+ Merge func(t1, t2 Type) (Type, error)

+ Mutable func(t Type) (Type, error)

+ NonNullable func(t Type) (Type, error)

+ Omit func(t Type, keys ...string) (Type, error)

+ Optional func(t Type) Type

+ Partial func(t Type) (Type, error)

+ Pick func(t Type, keys ...string) (Type, error)

+ Readonly func(t Type) (Type, error)

+ Record func(keyType, valueType Type) Type

+ Required func(t Type) (Type, error)

+ Union func(types ...Type) Type

+ Values func(t Type) ([]Type, error)

+ var GlobalTypeUtils TypeUtils = NewTypeUtils()

+ func NewTypeUtils() TypeUtils

+ type UnionConstraint struct

+ func NewUnionConstraint(constraints ...Constraint) *UnionConstraint

+ func TypesToUnionConstraint(types ...Type) *UnionConstraint

+ func (uc *UnionConstraint) SatisfiedBy(t Type) bool

+ func (uc *UnionConstraint) String() string

+ type UnionType struct

+ func NewUnionType(types ...Type) *UnionType

+ func (u *UnionType) AssignableTo(t Type) bool

+ func (u *UnionType) ConvertibleTo(t Type) bool

+ func (u *UnionType) Implements(t Type) bool

+ func (u *UnionType) Kind() ObjKind

+ func (u *UnionType) Name() string

+ func (u *UnionType) New(values ...Value) Value

+ func (u *UnionType) Text() string

+ type Value interface

+ Interface func() any

+ Text func() string

+ Type func() Type

+ type VariablePattern struct

+ Type Type

+ VariableName string

+ func (vp *VariablePattern) Match(value Value) bool

+ type Variance int

+ const Bivariant

+ const Contravariant

+ const Covariant

+ const Invariant

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