datalog/it.unibo.tuprolog.datalog/ClauseVisitor

ClauseVisitor

interface ClauseVisitor<T> : TermVisitor<T>

A TermVisitor specialised for walking a Clause literal by literal, rather than term by term: instead of overriding TermVisitor.visitClause directly, implementors get separate hooks for the clause's head and for each body literal, further split into the negated (visitNegatedLiteral) and non-negated (visitNonNegatedLiteral) case — the very distinction the Datalog well-formedness checks in it.unibo.tuprolog.datalog are built on (see it.unibo.tuprolog.datalog.isNegated).

it.unibo.tuprolog.datalog.visitors.AbstractClauseVisitor is the base implementation that does the actual dispatching (head vs. body, negated vs. non-negated) on top of this interface; it.unibo.tuprolog.datalog.visitors.CompoundFinder is a concrete example.

Inheritors

AbstractClauseVisitor

Functions

defaultValue

abstract fun defaultValue(term: Term): T

visitAtom

open fun visitAtom(term: Atom): T

visitBlock

open fun visitBlock(term: Block): T

visitClause

abstract override fun visitClause(term: Clause): T

visitCollection

open fun visitCollection(term: Recursive): T

visitCons

open fun visitCons(term: Cons): T

visitConstant

open fun visitConstant(term: Constant): T

visitDirective

open fun visitDirective(term: Directive): T

visitEmpty

open fun visitEmpty(term: Empty): T

visitEmptyBlock

open fun visitEmptyBlock(term: EmptyBlock): T

visitEmptyList

open fun visitEmptyList(term: EmptyList): T

visitFact

open fun visitFact(term: Fact): T

visitHead

open fun visitHead(head: Struct): T

Visits the head of a Clause (a no-op wrapper around visitLiteral by default).

visitIndicator

open fun visitIndicator(term: Indicator): T

visitInteger

open fun visitInteger(term: Integer): T

visitList

open fun visitList(term: List): T

visitLiteral

abstract fun visitLiteral(literal: Struct): T

Visits any literal (head or body) of a Clause, regardless of whether it is negated.

visitNegatedLiteral

open fun visitNegatedLiteral(literal: Struct): T

Visits a body literal known to be negated, receiving the literal inside the not(...)/\+(...) wrapper (not the wrapper itself). Falls back to visitLiteral.