PrologTerm (prolobjectlink-jpi 1.2-SNAPSHOT API)

All Superinterfaces:

Comparable<PrologTerm>, PrologElement

All Known Subinterfaces:

PrologAtom, PrologDouble, PrologEntry, PrologFloat, PrologInteger, PrologList, PrologLong, PrologMap, PrologNumber, PrologReference, PrologStructure, PrologVariable

All Known Implementing Classes:

AbstractCompounds, AbstractTerm, PrologBuiltin
```
public interface PrologTerm
extends Comparable<PrologTerm>, PrologElement
```
Ancestor prolog data type. All Prolog data types PrologAtom, PrologNumber, PrologList, PrologStructure and PrologVariable are derived from this class. All before mentioned classes extends from this class the commons responsibilities. Extends from Comparable to compare the current term with another term based on Standard Order.

The Prolog Provider is the mechanism to create a new Prolog terms invoking the correspondent methods. PrologProvider.newAtom(String) for atoms, PrologProvider.newStructure(String, PrologTerm...) for structures, PrologProvider.newVariable(String, int) for variables and so on.

With getType() the term type can be retrieve. Every term have a type defined in PrologTermType. The prolog type have by definition one order (Standard Order) where Variables < Atoms < Numbers < Compounds. This order is usable to compare two terms.

Prolog terms have two specials properties, the functor and the arity. Functor is the compound term or atom name and arity is the number of arguments present in the compound terms. Variable and Number don't have this properties. This properties are accessible from getArity() and getFunctor() methods. Variable and Number raise an ArityError and FunctorError respectively. Based on functor and arity atoms and compound terms have a predicate indicator that is the signature for the term. The term indicator is an string formed by the concatenation of getFunctor() and getArity() separated by slash.

The methods getArguments() and getArgument(int) allow retrieve the arguments and the some specific arguments for compounds terms respectively. For atomics terms getArguments() return an empty term array and getArgument(int) raise a ArrayIndexOutOfBoundsException because don't have arguments. For this cases is a good practice check compound terms before invoke this methods.
```
 if (t.isCompound()) {
        PrologTerm x = t.getArgument(i);
        System.out.println(x);
 }
 
```
Prolog unification is the process that involves one or more variables such that they are instantiated with the necessary terms in order to make two terms are identical. The prolog term interface provide unify(PrologTerm) method to check that the current term unify with the given term. Prolog unification algorithm is based on three principals rules:
- If x and y are atomics constants then x and y unify only if they are same object.
- If x is a variable and y is anything then they unify and x is instantiated to y. Conversely, if y is a variable then this is instantiated to x.
- If x and y are structured terms then unify only if they match (equals funtor and arity) and all their correspondents arguments unify.
```
 PrologAtom atom = provider.newAtom("smith");
 PrologAtom atom1 = provider.newAtom("doe");
 // true because the atoms are equals
 assertTrue(atom.unify(atom));
 // false because the atoms are different
 assertFalse(atom.unify(atom1));
 PrologVariable variable = provider.newVariable("X", 0);
 // true because atom and variable unify
 assertTrue(atom.unify(variable));
 
```
Since:

1.0

Author:

Jose Zalacain

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`<T extends PrologTerm> T`	`cast()` Casts the current PrologTerm to the class or interface represented by this `Class` object.
`PrologTerm`	`getArgument(int index)` Term located at some given index position in the current term arguments if current term is a compound term.
`PrologTerm[]`	`getArguments()` Term arguments if the current term is a compound term.
`int`	`getArity()` Term arity.
`String`	`getFunctor()` Term functor.The functor of a term is a name for compound terms.
`String`	`getIndicator()` Gets the term indicator represented by one string with the format functor/arity.
`Object`	`getObject()` For references terms return the referenced object.
`PrologProvider`	`getProvider()` Prolog provider associated to the current term.
`PrologTerm`	`getTerm()` Return current term instance if current term is not a variable or is a free variable term.
`int`	`getType()` Get the term type.
`boolean`	`hasIndicator(String functor, int arity)` True if term has an indicator with the format functor/arity that match with the given functor and arity.
`boolean`	`isAtom()` True if this term is an atom
`boolean`	`isAtomic()` True if this Term is a atomic term, false in other case
`boolean`	`isClass()` Deprecated.
`boolean`	`isCompound()` True if this Term is a compound term, false in other case
`boolean`	`isDouble()` True if this Term is a double precision floating point number, false in other case
`boolean`	`isEmptyList()` True if this Term is a empty list term ([]), false in other case
`boolean`	`isEntry()` True if this Term is a Entry, false in other case
`boolean`	`isEvaluable()` Check if the current term is a compound term and have like functor an operator.
`boolean`	`isFalseType()` Check if the current term is a reference term and the referenced object is an instance of java false value.
`boolean`	`isField()` Deprecated.
`boolean`	`isFloat()` True if this Term is a single precision floating point number, false in other case
`boolean`	`isInteger()` True if this Term is an integer number, false in other case
`boolean`	`isList()` True if this Term is a list, false in other case
`boolean`	`isLong()` True if this Term is a large integer number, false in other case
`boolean`	`isMap()` True if this Term is a Map, false in other case
`boolean`	`isMixin()` Deprecated.
`boolean`	`isNil()` True if this Term is a nil term (null term for prolog), false in other case
`boolean`	`isNullType()` Check if the current term is a reference term and the referenced object is a java null value.
`boolean`	`isNumber()` True if this term is an number
`boolean`	`isObjectType()` Check if the current term is a reference term for some java object instance.
`boolean`	`isParameter()` Deprecated.
`boolean`	`isReference()` Check if the current term is a reference term for some java object instance or is a reference term and the referenced object is a java null value.
`boolean`	`isResult()` Deprecated.
`boolean`	`isStructure()` True if this Term is a structured term, false in other case
`boolean`	`isTrueType()` Check if the current term is a reference term and the referenced object is an instance of java true value.
`boolean`	`isVariable()` True if this Term is a variable, false in other case
`boolean`	`isVariableBound()` True if this Term is a instanced variable, false in other case
`boolean`	`isVariableNotBound()` True if this Term is a not instanced variable, false in other case
`boolean`	`isVoidType()` Check if the current term is a reference term for java void type.
`Map<String,PrologTerm>`	`match(PrologTerm term)` Match to other term returning list of substitutions.
`boolean`	`unify(PrologTerm term)` Check that the current term unify with the given term.

Methods inherited from interface java.lang.Comparable
compareTo

Methods inherited from interface io.github.prolobjectlink.prolog.PrologElement
isClause, isTerm

- Method Detail
  - getIndicator
```
String getIndicator()
```
    Gets the term indicator represented by one string with the format functor/arity. More formally the indicator string is formed by the concatenation of getFunctor() and getArity() separated by slash.
    
    Returns:
    
    term indicator
    
    Since:
    
    1.0
  - hasIndicator
```
boolean hasIndicator(String functor,
                     int arity)
```
    True if term has an indicator with the format functor/arity that match with the given functor and arity.
    
    Parameters:
    
    functor - term functor
    
    arity - term arity
    
    Returns:
    
    True if term has an indicator functor/arity.
    
    Since:
    
    1.0
  - getType
```
int getType()
```
    Get the term type.
    
    Returns:
    
    term type.
    
    Since:
    
    1.0
  - isAtom
```
boolean isAtom()
```
    True if this term is an atom
    
    Returns:
    
    whether this Term represents an atom, false in other case
    
    Since:
    
    1.0
  - isNumber
```
boolean isNumber()
```
    True if this term is an number
    
    Returns:
    
    whether this Term represents an number, false in other case
    
    Since:
    
    1.0
  - isFloat
```
boolean isFloat()
```
    True if this Term is a single precision floating point number, false in other case
    
    Returns:
    
    whether this Term represents a single precision floating point number, false in other case
    
    Since:
    
    1.0
  - isInteger
```
boolean isInteger()
```
    True if this Term is an integer number, false in other case
    
    Returns:
    
    whether this Term represents an integer number
    
    Since:
    
    1.0
  - isDouble
```
boolean isDouble()
```
    True if this Term is a double precision floating point number, false in other case
    
    Returns:
    
    whether this Term represents a double precision floating point number, false in other case
    
    Since:
    
    1.0
  - isLong
```
boolean isLong()
```
    True if this Term is a large integer number, false in other case
    
    Returns:
    
    whether this Term represents a large integer number, false in other case
    
    Since:
    
    1.0
  - isVariable
```
boolean isVariable()
```
    True if this Term is a variable, false in other case
    
    Returns:
    
    whether this Term is a variable
    
    Since:
    
    1.0
  - isVariableBound
```
boolean isVariableBound()
```
    True if this Term is a instanced variable, false in other case
    
    Returns:
    
    whether this Term is a instanced variable
    
    Since:
    
    1.1
  - isVariableNotBound
```
boolean isVariableNotBound()
```
    True if this Term is a not instanced variable, false in other case
    
    Returns:
    
    whether this Term is a not instanced variable
    
    Since:
    
    1.1
  - isList
```
boolean isList()
```
    True if this Term is a list, false in other case
    
    Returns:
    
    whether this Term is a list
    
    Since:
    
    1.0
  - isStructure
```
boolean isStructure()
```
    True if this Term is a structured term, false in other case
    
    Returns:
    
    whether this Term is a structured term
    
    Since:
    
    1.0
  - isNil
```
boolean isNil()
```
    True if this Term is a nil term (null term for prolog), false in other case
    
    Returns:
    
    whether this Term is a nil term
    
    Since:
    
    1.0
  - isEmptyList
```
boolean isEmptyList()
```
    True if this Term is a empty list term ([]), false in other case
    
    Returns:
    
    whether this Term is a empty list term
    
    Since:
    
    1.0
  - isAtomic
```
boolean isAtomic()
```
    True if this Term is a atomic term, false in other case
    
    Returns:
    
    whether this Term is a atomic term
    
    Since:
    
    1.0
  - isCompound
```
boolean isCompound()
```
    True if this Term is a compound term, false in other case
    
    Returns:
    
    whether this Term is a compound term
    
    Since:
    
    1.0
  - isEvaluable
```
boolean isEvaluable()
```
    Check if the current term is a compound term and have like functor an operator.
    
    Returns:
    
    true if current term have like functor an operator.
    
    Since:
    
    1.0
  - isTrueType
```
boolean isTrueType()
```
    Check if the current term is a reference term and the referenced object is an instance of java true value. Most formally check if the reference term is @(true) structure.
    
    Returns:
    
    true if current term have like referenced object an instance of java true value.
    
    Since:
    
    1.0
  - isFalseType
```
boolean isFalseType()
```
    Check if the current term is a reference term and the referenced object is an instance of java false value. Most formally check if the reference term is @(false) structure.
    
    Returns:
    
    true if current term have like referenced object an instance of java false value.
    
    Since:
    
    1.0
  - isNullType
```
boolean isNullType()
```
    Check if the current term is a reference term and the referenced object is a java null value. Most formally check if the reference term is @(null) structure.
    
    Returns:
    
    true if current term have like referenced object a java null value.
    
    Since:
    
    1.0
  - isVoidType
```
boolean isVoidType()
```
    Check if the current term is a reference term for java void type. Most formally check if the reference term is @(void) structure.
    
    Returns:
    
    true if current term is a referenced to java void type.
    
    Since:
    
    1.0
  - isObjectType
```
boolean isObjectType()
```
    Check if the current term is a reference term for some java object instance. Most formally check if the reference term is an structure like @(J#00000000000000000425).
    
    Returns:
    
    true if current term is a referenced for some java object instance.
    
    Since:
    
    1.0
  - isReference
```
boolean isReference()
```
    Check if the current term is a reference term for some java object instance or is a reference term and the referenced object is a java null value.
    
    Returns:
    
    true if current term is a reference term for object instance or java null value.
    
    Since:
    
    1.0
  - isEntry
```
boolean isEntry()
```
    True if this Term is a Entry, false in other case
    
    Returns:
    
    whether this Term is a entry
    
    Since:
    
    1.1
  - isMap
```
boolean isMap()
```
    True if this Term is a Map, false in other case
    
    Returns:
    
    whether this Term is a map
    
    Since:
    
    1.1
  - isField
```
@Deprecated
boolean isField()
```
    Deprecated.
    
    True if this Term is a Field, false in other case
    
    Returns:
    
    whether this Term is a field
    
    Since:
    
    1.1
  - isResult
```
@Deprecated
boolean isResult()
```
    Deprecated.
    
    True if this Term is a Result, false in other case
    
    Returns:
    
    whether this Term is a result
    
    Since:
    
    1.1
  - isParameter
```
@Deprecated
boolean isParameter()
```
    Deprecated.
    
    True if this Term is a Parameter, false in other case
    
    Returns:
    
    whether this Term is a parameter
    
    Since:
    
    1.1
  - isMixin
```
@Deprecated
boolean isMixin()
```
    Deprecated.
    
    True if this Term is a Mixin, false in other case
    
    Returns:
    
    whether this Term is a mixin
    
    Since:
    
    1.1
  - isClass
```
@Deprecated
boolean isClass()
```
    Deprecated.
    
    True if this Term is a Class, false in other case
    
    Returns:
    
    whether this Term is a class
    
    Since:
    
    1.1
  - getObject
```
Object getObject()
```
    For references terms return the referenced object.
    
    Returns:
    
    the referenced object if the current term is a reference prolog term
    
    Since:
    
    1.0
  - getTerm
```
PrologTerm getTerm()
```
    Return current term instance if current term is not a variable or is a free variable term. If current term is a variable bound term then return the linked term hold by this variable after dereferencing.
    
    Returns:
    
    return a dereferencing term if current term is bound variable, current term in otherwise
    
    Since:
    
    1.0
  - getArity
```
int getArity()
```
    Term arity. The arity of a term is a argument number for compound terms. If a the current term is not a compound term, then an exception is raised indicating a violation.
    
    Returns:
    
    term arity for compound terms or an exception is raised if the term is not a compound term.
    
    Since:
    
    1.0
  - getFunctor
```
String getFunctor()
```
    Term functor.The functor of a term is a name for compound terms. If a the current term is not a compound term, then an exception is raised indicating a violation.
    
    Returns:
    
    term functor for compound terms or an exception is raised if the term is not a compound term.
    
    Since:
    
    1.0
  - getArguments
```
PrologTerm[] getArguments()
```
    Term arguments if the current term is a compound term. Compound terms are Structures and List data types. They are compoused by a PrologTerm[] array. Atoms, Variables and Numbers return an empty term array.
    
    Returns:
    
    Term arguments if the current term is a compound term.
    
    Since:
    
    1.0
  - getArgument
```
PrologTerm getArgument(int index)
```
    Term located at some given index position in the current term arguments if current term is a compound term. If the current term is not compound term an ArrayIndexOutOfBoundsException exception is raised.
    
    Parameters:
    
    index - position to retrieve the correspondent term.
    
    Returns:
    
    Term located at some given index position.
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if the index value is out of term array bound.
    
    Since:
    
    1.0
  - unify
```
boolean unify(PrologTerm term)
```
    Check that the current term unify with the given term. Prolog unification algorithm is based on three principals rules:
    - If x and y are atomics constants then x and y unify only if they are same object.
    - If x is a variable and y is anything then they unify and x is instantiated to y. Conversely, if y is a variable then this is instantiated to x.
    - If x and y are structured terms then unify only if they match (equals funtor and arity) and all their correspondents arguments unify.
    Parameters:
    
    term - the term to unify with the current term
    
    Returns:
    
    true if the specified term unify whit the current term, false if not
    
    Since:
    
    1.0
  - match
```
Map<String,PrologTerm> match(PrologTerm term)
```
    Match to other term returning list of substitutions.
    
    Parameters:
    
    term - - term to match check
    
    Returns:
    
    list of substitutions.
    
    Since:
    
    1.1
  - getProvider
```
PrologProvider getProvider()
```
    Prolog provider associated to the current term.
    
    Returns:
    
    Prolog provider associated to the current term.
    
    Since:
    
    1.0
  - cast
```
<T extends PrologTerm> T cast()
```
    Casts the current PrologTerm to the class or interface represented by this Class object.
    
    Returns:
    
    the PrologTerm after casting, or null if term is null
    
    Throws:
    
    ClassCastException - if the object is not null and is not assignable to the type T.
    
    Since:
    
    1.1

Interface PrologTerm

Method Summary

Methods inherited from interface java.lang.Comparable

Methods inherited from interface io.github.prolobjectlink.prolog.PrologElement

Method Detail

getIndicator

hasIndicator

getType

isAtom

isNumber

isFloat

isInteger

isDouble

isLong

isVariable

isVariableBound

isVariableNotBound

isList

isStructure

isNil

isEmptyList

isAtomic

isCompound

isEvaluable

isTrueType

isFalseType

isNullType

isVoidType

isObjectType

isReference

isEntry

isMap

isField

isResult

isParameter

isMixin

isClass

getObject

getTerm

getArity

getFunctor

getArguments

getArgument

unify

match

getProvider

cast