vm

type Addr ¶

type Addr uint32

Addr is data type on defining heap addresses

func (addr Addr) IsWritable() bool

func (addr Addr) ReadOnly() Addr

func (addr Addr) String() string

func (addr Addr) Value() uint32

type Generator ¶

type Generator func([]Addr) Stream

Generator is σ-expressions that define ground facts for the application context. Typically, Generator fetches ground facts from external storage.

type Heap ¶

type Heap []xsd.Value

Heap of VM

func (heap *Heap) Dump()

func (heap *Heap) Get(addr Addr) xsd.Value

func (heap *Heap) Put(addr Addr, val xsd.Value)

func (heap *Heap) UnsafeGet(addr Addr) xsd.Value

type Reader ¶

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

VM returns Reader as a result of σ-application. VM associates reader object with goal of the application (σ-stream) that allows a client to use `interface{ Read([]any) error }` as lazy consumer of the relation.

func (reader *Reader) Read(seq []xsd.Value) error

func (reader *Reader) ToSeq() [][]xsd.Value

type Stream ¶

type Stream interface {
	// init stream & read head
	Init(*Heap) error
	// continue stream reading
	Read(*Heap) error
}

Stream of relations is core abstraction used by the VM. Stream produces lazy sequence of relations (tuples).

for err := stream.Init(&h); err == nil; err = stream.Read(&h) {
 ...
}

func Eq(x, y []Addr, stream Stream) Stream

func Horn(seq ...Stream) Stream

func Join(lhs, rhs Stream) Stream

for err := head.Init(&h); err == nil; err = head.Read(&h) {
  for err := tail.Init(&h); err == nil; err = tail.Read(&h) {
    ...
  }
}

type VM ¶

type VM struct {
	Heap Heap
}

Sigma VM

func New(memSize int) *VM

func (vm *VM) Run(head []Addr, stream Stream) [][]xsd.Value

func (vm *VM) Stream(head []Addr, stream Stream) *Reader