Method oneStepEvalPremise

engine/naivebottomup.go:148–200

Evaluates a single premise atom by scanning facts.

(premise ast.Term, subst unionfind.UnionFind)

// Evaluates a single premise atom by scanning facts.
func (e naiveEngine) oneStepEvalPremise(premise ast.Term, subst unionfind.UnionFind) []unionfind.UnionFind {
	var solutions []unionfind.UnionFind
	switch p := premise.(type) {
	case ast.Atom:
		p, err := functional.EvalAtom(p, subst)
		if err != nil {
			return nil
		}
		if p.Predicate.IsBuiltin() {
			res, nsubsts, err := builtin.Decide(p, &subst)
			if err != nil {
				// Treat errors in built-in predicate evaluation as false.
				return nil
			}
			if !res {
				return nil
			}
			for _, nsubst := range nsubsts {
				solutions = append(solutions, *nsubst)
			}
			return solutions
		}
		// Not a built-in predicate.
		e.store.GetFacts(p, func(fact ast.Atom) error {
			// TODO: This could be made a lot more efficient by using a persistent
			// data structure for composing the unionfind substitutions.
			if newsubst, err := unionfind.UnifyTermsExtend(p.Args, fact.Args, subst); err == nil {
				solutions = append(solutions, newsubst)
			}
			return nil
		})
	case ast.NegAtom:
		a, err := functional.EvalAtom(p.Atom, subst)
		if err != nil {
			return nil
		}
		e.store.GetFacts(a, func(fact ast.Atom) error {
			if _, err := unionfind.UnifyTermsExtend(p.Atom.Args, fact.Args, subst); err != nil {
				solutions = append(solutions, subst)
			}
			return nil
		})
	case ast.Eq:
		if newsubst, err := unionfind.UnifyTermsExtend([]ast.BaseTerm{p.Left}, []ast.BaseTerm{p.Right}, subst); err == nil {
			solutions = append(solutions, newsubst)
		}
	case ast.Ineq:
		if _, err := unionfind.UnifyTermsExtend([]ast.BaseTerm{p.Left}, []ast.BaseTerm{p.Right}, subst); err != nil {
			solutions = append(solutions, subst)
		}
	}
	return solutions
}