schema

type AnySchema[F any] Schema[F, Constraint[F]]

type Assignment[F any] interface {
	// For the given module, determine any well-definedness bounds implied by
	// this assignment in  both the negative (left) or positive (right)
	// directions.  For example, consider an expression such as "(shift X -1)".
	// This is technically undefined for the first row of any trace and, by
	// association, any assignment evaluating this expression on that first row
	// is also undefined.
	Bounds(ModuleId) util.Bounds
	// ComputeColumns computes the values of columns defined by this assignment.
	// In order for this computation to makes sense, all columns on which this
	// assignment depends must exist (e.g. are either inputs or have been
	// computed already).  Computed columns do not exist in the original trace,
	// but are added during trace expansion to form the final trace.
	Compute(tr.Trace[F], AnySchema[F]) ([]array.MutArray[F], error)
	// Consistent applies a number of internal consistency checks.  Whilst not
	// strictly necessary, these can highlight otherwise hidden problems as an aid
	// to debugging.
	Consistent(AnySchema[F]) []error
	// Identifier registers which are expanded by this assignment.  A register
	// is expanded when its length maybe changed.  For example, when going from
	// a trace which contains only rows of input/output values to a trace where
	// each function instance can occupy more than one row.  Then the I/O
	// columns are said to be "expanded".
	RegistersExpanded() []register.Ref
	// Returns the set of columns that this assignment depends upon.  That can
	// include both input columns, as well as other computed columns.
	RegistersRead() []register.Ref
	// Identifier registers assigned by this assignment.
	RegistersWritten() []register.Ref
	// Substitute any matchined labelled constants within this assignment
	Substitute(map[string]F)
	// Lisp converts this schema element into a simple S-Expression, for example
	// so it can be printed.
	Lisp(AnySchema[F]) sexp.SExp
}

type Constraint[F any] interface {
	// Accepts determines whether a given constraint accepts a given trace or
	// not.  If not, a failure is produced.  Otherwise, a bitset indicating
	// branch coverage is returned.
	Accepts(trace.Trace[F], AnySchema[F]) (bit.Set, Failure)
	// Determine the well-definedness bounds for this constraint in both the
	// negative (left) or positive (right) directions.  For example, consider an
	// expression such as "(shift X -1)".  This is technically undefined for the
	// first row of any trace and, by association, any constraint evaluating
	// this expression on that first row is also undefined (and hence must pass)
	Bounds(module uint) util.Bounds
	// Consistent applies a number of internal consistency checks.  Whilst not
	// strictly necessary, these can highlight otherwise hidden problems as an aid
	// to debugging.
	Consistent(AnySchema[F]) []error
	// Contexts returns the evaluation contexts (i.e. enclosing module + length
	// multiplier) for this constraint.  Most constraints have only a single
	// evaluation context, though some (e.g. lookups) have more.  Note that all
	// constraints have at least one context (which we can call the "primary"
	// context).
	Contexts() []ModuleId
	// Name returns a unique name for a given constraint.  This is useful purely
	// for identifying constraints in reports, etc.
	Name() string
	// Lisp converts this schema element into a simple S-Expression, for example
	// so it can be printed.
	Lisp(AnySchema[F]) sexp.SExp
	// Substitute any matchined labelled constants within this constraint
	Substitute(map[string]F)
}

type Failure interface {
	// Provides a suitable error message
	Message() string
}

type Module[F any] interface {
	ModuleView
	// AllowPadding determines whether the given module allows an initial
	// padding row, or not.
	AllowPadding() bool
	// Assignments returns an iterator over the assignments of this module.
	// These are the computations used to assign values to all computed columns
	// in this module.
	Assignments() iter.Iterator[Assignment[F]]
	// Constraints provides access to those constraints associated with this
	// module.
	Constraints() iter.Iterator[Constraint[F]]
	// Consistent applies a number of internal consistency checks.  Whilst not
	// strictly necessary, these can highlight otherwise hidden problems as an aid
	// to debugging.
	Consistent(fieldWidth uint, schema AnySchema[F]) []error
	// Keys returns the number n of key columns in this module.  Key columns are
	// always the first n columns in a module.  Such columns have the property
	// that they can be used in conjunction with Find.
	Keys() uint
	// StaticContents returns the contents of this module, assuming it
	// corresponds with a static reference table.  Each entry in the entries
	// array returned should have Width() elements and correspond to a row in
	// the static module.  NOTE: this will panic when IsStatic() is false (i.e.
	// since only static modules can have contents).
	StaticContents() (entries [][]F)
	// Substitute any matchined labelled constants within this module
	Substitute(map[string]F)
}

type ModuleId = uint

type ModuleView interface {
	register.Map
	// Module name
	Name() module.Name
	// IsPublic indicates whether or not this module is externally visible.
	IsPublic() bool
	// IsSynthetic modules are generated during compilation, rather than being
	// provided by the user.
	IsSynthetic() bool
	// IsNative indicates whether this module corresponds to a function backed
	// by a native circuit (i.e. declared with the @native annotation in ZkC).
	// Only modules produced by the ZkC pipeline can ever be native; modules
	// from any other source always return false.
	IsNative() bool
	// IsStatic indicates whether this module represents a static reference
	// table whose contents are fixed at compile time.  Static modules carry
	// their data in StaticContents() (queried via the field-parameterised
	// schema.Module interface).
	IsStatic() bool
	// Returns the number of registers in this module.
	Width() uint
}

type Schema[F any, C any] interface {
	// Assignments returns an iterator over the assignments of this schema.
	// That is, the set of computations used to determine values for all
	// computed columns.
	Assignments() iter.Iterator[Assignment[F]]
	// Consistent applies a number of internal consistency checks.  Whilst not
	// strictly necessary, these can highlight otherwise hidden problems as an aid
	// to debugging.
	Consistent(fieldWidth uint) []error
	// Constraints returns an iterator over all constraints defined in this
	// schema.  Observe that this does include assertions which, strictly
	// speaking, are not constraints in the true sense.  That is, they are never
	// compiled into vanishing polynomials but, instead, are used purely for
	// debugging.
	Constraints() iter.Iterator[C]
	// HasModule checks whether a module with the given name exists and, if so,
	// returns its module identifier.  Otherwise, it returns false.
	HasModule(name module.Name) (ModuleId, bool)
	// Access a given module in this schema.
	Module(module uint) Module[F]
	// Modules returns an iterator over the declared set of modules within this
	// schema.
	Modules() iter.Iterator[Module[F]]
	// Access a given register in this schema.
	Register(register.Ref) register.Register
	// Returns the number of modules in this schema.
	Width() uint
}

type Table[F field.Element[F], C Constraint[F]] struct {
	// contains filtered or unexported fields
}

type UniformSchema[F any, M Module[F]] struct {
	// contains filtered or unexported fields
}