MutableTheory

interface MutableTheory : Theory

Types

Companion

object Companion

Functions

abolish

abstract override fun abolish(indicator: Indicator): MutableTheory

assertA

abstract override fun assertA(clause: Clause): MutableTheory

Adds given clause before all other clauses in this theory

open override fun assertA(struct: Struct): MutableTheory

Adds given clause before all other clauses in this theory

abstract override fun assertA(clauses: Iterable<Clause>): MutableTheory

Adds the given clauses before all other clauses in this theory

abstract override fun assertA(clauses: Sequence<Clause>): MutableTheory

Adds the given clauses before all other clauses in this theory

assertZ

abstract override fun assertZ(clause: Clause): MutableTheory

Adds given clause after all other clauses in this theory

open override fun assertZ(struct: Struct): MutableTheory

Adds given clause after all other clauses in this theory

abstract override fun assertZ(clauses: Iterable<Clause>): MutableTheory

Adds the given clauses after all other clauses in this theory

abstract override fun assertZ(clauses: Sequence<Clause>): MutableTheory

Adds the given clauses after all other clauses in this theory

clone

abstract override fun clone(): MutableTheory

contains

abstract operator fun contains(clause: Clause): Boolean

Checks if given clause is contained in this theory

abstract operator fun contains(indicator: Indicator): Boolean

Checks if clauses exists in this theory having the specified Indicator as head; this should be well-formed

abstract operator fun contains(head: Struct): Boolean

Checks if given clause is present in this theory

containsTag

open fun containsTag(name: String): Boolean

equals

abstract fun equals(other: Theory, useVarCompleteName: Boolean): Boolean

get

abstract operator fun get(clause: Clause): Sequence<Clause>

Retrieves matching clauses from this theory

abstract operator fun get(indicator: Indicator): Sequence<Rule>

Retrieves all rules in this theory having the specified Indicator as head; this should be well-formed

abstract operator fun get(head: Struct): Sequence<Rule>

Retrieves matching rules from this theory

getTag

open fun <T : Any> getTag(name: String): T?

iterator

abstract operator fun iterator(): Iterator<Clause>

plus

open operator override fun plus(clause: Clause): MutableTheory

Adds given Clause to this Theory

abstract operator override fun plus(theory: Theory): MutableTheory

Adds given Theory to this

replaceTags

abstract override fun replaceTags(tags: Map<String, Any>): MutableTheory

retract

abstract override fun retract(clause: Clause): RetractResult<MutableTheory>

Tries to delete a matching clause from this theory

open override fun retract(head: Struct): RetractResult<MutableTheory>

Tries to delete a matching clause from this theory

abstract override fun retract(clauses: Iterable<Clause>): RetractResult<MutableTheory>

Tries to delete the matching clauses from this theory

abstract override fun retract(clauses: Sequence<Clause>): RetractResult<MutableTheory>

Tries to delete the matching clauses from this theory

retractAll

abstract override fun retractAll(clause: Clause): RetractResult<MutableTheory>

Tries to delete all matching clauses from this theory

open override fun retractAll(head: Struct): RetractResult<MutableTheory>

Tries to delete all matching clauses from this theory

toImmutableTheory

abstract fun toImmutableTheory(): Theory

toMutableTheory

open override fun toMutableTheory(): MutableTheory

toString

abstract fun toString(asPrologText: Boolean): String

An enhanced toString that prints the theory in a Prolog program format, if asPrologText is true

Properties

clauses

abstract val clauses: Iterable<Clause>

All Clauses in this theory

directives

open val directives: Iterable<Directive>

Only clauses that are Directives

isMutable

open override val isMutable: Boolean

rules

open val rules: Iterable<Rule>

Only clauses that are Rules

size

abstract val size: Long

The amount of clauses in this Theory