rt

type Aspect struct {
	Name   string // matches the field name
	Traits []string
}

type Assignment interface {
	GetAssignedValue(Runtime) (Value, error)
}

type BoolEval interface {
	GetBool(Runtime) (Value, error)
}

type Execute interface {
	Execute(Runtime) error
}

type Field struct {
	Name     string          // name of the field, unique within the kind
	Affinity affine.Affinity // one of the built in data types
	Type     string          // subtype; ex. kind for text types
	Init     Assignment      // default initialization
}

type Jump int

type Kind struct {
	// indicates ancestry, the name of this kind at the start, parent kinds to the right.
	// can be nil if anonymous
	Path []string
	// holds the accumulated fields of all ancestors.
	// parent fields to the *left*, more derived fields to the right. ( the reverse of path. )
	// descendant kinds can have different initial assignments for the same named field.
	Fields []Field
	// a subset of fields for those containing traits
	// see MakeAspects.
	Aspects []Aspect
	// contains filtered or unexported fields
}

type Kinds interface {
	GetKindByName(n string) (*Kind, error)
}

type NilRecord struct {
	Class string // name of the record type that the field wants
	Field int    // index of the field in its parent record
}

type NumListEval interface {
	GetNumList(Runtime) (Value, error)
}

type NumberEval interface {
	GetNumber(Runtime) (Value, error)
}

type PanicValue struct{}

type Record struct {
	*Kind
	// contains filtered or unexported fields
}

type RecordEval interface {
	GetRecord(Runtime) (Value, error)
}

type RecordListEval interface {
	GetRecordList(Runtime) (Value, error)
}

type Rule struct {
	Name string
	// controls the style of transition:
	// when true, stops processing of any other rules; otherwise moves to the next phase.
	// a stop before the main rule is considered a canceled action;
	// and the result of the action in that case is false.
	Stop bool
	// controls when a transitions happens
	Jump Jump
	// whether the rule needs to be updated
	// before jumping to the next phase ( ex. for counters )
	Updates bool
	// a chain of if-else statements is considered an "optional" rule;
	// otherwise its considered a mandatory rule.
	// mandatory rules block other rules from running ( based on stop/stop )
	// optional rules only block other rules if some part of the if chain tested true.
	Exe []Execute
}

type Runtime interface {
	// ActivateDomain - objects are grouped into potentially hierarchical "domains".
	// de/activating makes those groups hidden/visible to the runtime.
	// Domain hierarchy is defined at assembly time.
	ActivateDomain(name string) error
	// GetKindByName - type description
	GetKindByName(name string) (*Kind, error)
	// Call - run the pattern defined by the passed record.
	// passes the expected return because patterns can be called in ambiguous context ( ex. template expressions )
	Call(name string, expectedReturn affine.Affinity, keys []string, vals []Value) (Value, error)
	// RelativesOf - returns a list, even for one-to-one relationships.
	RelativesOf(a, relation string) (Value, error)
	// ReciprocalsOf - returns a list, even for one-to-one relationships.
	ReciprocalsOf(b, relation string) (Value, error)
	// RelateTo - establish a new relation between nouns and and b.
	RelateTo(a, b, relation string) error
	// PushScope - modifies the behavior of Get/SetField meta.Variable
	// by adding a set of variables to the current namespace.
	// ex. loops add iterators
	PushScope(Scope)
	// PopScope - remove the most recently added set of variables from the internal stack.
	PopScope()
	// GetField - various runtime objects (ex. nouns, kinds, etc.) store data addressed by name.
	// the objects and their fields depend on implementation and context.
	// see package meta for a variety of common objects.
	GetField(object, field string) (Value, error)
	// SetField - store, or at least attempt to store, a *copy* of the value into the field of the named object.
	// it can return an error:
	// if the value is not of a compatible type,
	// if the field is considered to read-only,
	// or if there is no object or field of the indicated names.
	SetField(object, field string, value Value) error
	// PluralOf - turn single words into their plural variants, and vice-versa.
	// each plural word maps to a unique singular.
	// for example, if the singular of "people" is "person", it cant also be "personage".
	PluralOf(single string) string
	// note: one plural word can map to multiple single words.
	// in that case the returned singular word is arbitrary ( if theoretically consistent )
	// for example, "person" can have the plural "people" or "persons" and this could return either.
	SingularOf(plural string) string
	// Random - return a pseudo-random number.
	Random(inclusiveMin, exclusiveMax int) int
	// Writer - Return the built-in writer, or the current override.
	Writer() io.Writer
	// SetWriter - Override the current writer.
	SetWriter(io.Writer) (prev io.Writer)
}

type Scope interface {
	// return g.Unknown if the named field/variable doesn't exist.
	FieldByName(field string) (Value, error)
	// set without copying
	SetFieldByName(field string, val Value) error
}

type TextEval interface {
	GetText(Runtime) (Value, error)
}

type TextListEval interface {
	GetTextList(Runtime) (Value, error)
}

type Unknown struct {
	Target, Field string
}

type Value interface {
	// identifies how the passed value is represented internally.
	// ex. a number can be represented as float or as an int,
	// a record might be one of several different kinds,
	// text might represent an object id of a specific kind, an aspect, trait, or other value.
	Type() string
	// identifies the general category of the value.
	Affinity() affine.Affinity
	// return this value as a bool, or panic if the value isn't a bool.
	Bool() bool
	// return this value as a float, or panic if the value isn't a number.
	Float() float64
	// return this value as an int, or panic if the value isn't a number.
	Int() int
	// return this value as a string; it doesn't panic.
	// for non-string values, similar to package reflect, it returns a string of the form "<type value>".
	String() string
	// return this value as a record, or panic if the value isn't a record.
	Record() *Record
	// return this value as a slice of floats, or panic if this isn't a float slice.
	// note: while primitive values support both ints and floats, slices can only be floats.
	Floats() []float64
	// return this value as a slice of strings, or panic if this isn't a string slice.
	Strings() []string
	// return this value as a slice of records, or panic if not a record slice.
	// note: every value in the returned slice is expected to be record of this value's Type().
	Records() []*Record
	// return a value representing a field inside this record.
	// if the field holds a record or a slice, the returned value shares its memory with the named field.
	// errors if note a record, or the field doesn't exist.
	FieldByName(string) (Value, error)
	// writes a *copy* of the passed value into a record.
	// errors if not a record, the field doesn't exist, or if its affinity cant support the passed value.
	SetFieldByName(string, Value) error
	// the number of elements in the value.
	// panics if this cant have a length: isnt a slice or a string.
	Len() int
	// return the nth element of this value, where 0 is the first value.
	// panics if this isn't a slice.
	Index(int) Value
	// writes a *copy* of the passed value into a slice
	// panics if this isn't a slice, if the index is out of range, or if the affinities are mismatched.
	// errors if the types are mismatched
	SetIndex(int, Value) error
	// adds a *copy* of a value, or a copy of a slice of values, to the end of this slice.
	// panics if this value isn't an appropriate kind of slice; errors on subtype.
	// In golang, this is a package level function, presumably to mirror the built-in append()
	Appends(Value) error
	// return a *copy* of this slice and its values containing the first index up to (and not including) the second index.
	// panics if this value isn't a slice.
	Slice(i, j int) (Value, error)
	// cut elements out of this slice from start to end,
	// adding copies of the passed additional elements (if any) at the start of the cut point.
	// Returns the cut elements, or an error if the start and end indices are bad.
	// panics if this value isn't a slice, or if additional element(s) are of an incompatible affinity.
	Splice(start, end int, add Value) (Value, error)
}