Modifier and Type | Field and Description |
---|---|
static EmptyList |
EMPTY_LIST
Singleton instance
|
Modifier and Type | Method and Description |
---|---|
void |
backtrack()
Reverts this term back to its original state prior to any unifications.
|
Term |
copy(Map<Variable,Variable> sharedVariables)
Returns a copy of this term.
|
Term[] |
getArgs()
Returns an array of this terms's arguments.
|
Term |
getArgument(int index)
Returns the term at the specified position in this term's arguments.
|
String |
getName()
Returns
ListFactory.LIST_PREDICATE_NAME . |
int |
getNumberOfArguments()
Returns the number of arguments in this term.
|
EmptyList |
getTerm()
Returns the current instantiated state of this term.
|
TermType |
getType()
Returns
TermType.EMPTY_LIST . |
boolean |
isImmutable()
Returns
true is this term is immutable. |
String |
toString() |
boolean |
unify(Term t)
Attempts to unify this term to the specified term.
|
public static final EmptyList EMPTY_LIST
For performance reasons, use t.getType()==TermType.EMPTY_LIST to check if a term is an empty list, rather than using t.getTerm()==EmptyList.EMPTY_LIST. TODO confirm this is what the code is doing
public void backtrack()
Term
Makes all Variable
s that this term consists of uninstantiated.
backtrack
in interface Term
Term.unify(Term)
public Term copy(Map<Variable,Variable> sharedVariables)
Term
public EmptyList getTerm()
Term
Returns a representation of this term with all instantiated Variable
s replaced with the terms they are
instantiated with.
public boolean isImmutable()
Term
true
is this term is immutable.
A term is considered immutable if its value will never change as a result of executing its Term.unify(Term)
or
Term.backtrack()
methods. A term will not be considered immutable if it is a Variable
or any of its
arguments are not immutable.
isImmutable
in interface Term
true
is this term is immutablepublic Term[] getArgs()
Term
Note: for performance reasons the array returned is the same array used internally be the term instance so be careful not to alter the array returned as changes will be reflected in the original term.
getArgs
in interface Term
Term.getArgument(int)
public int getNumberOfArguments()
Term
getNumberOfArguments
in interface Term
public Term getArgument(int index)
Term
getArgument
in interface Term
index
- index of the argument to returnArrayIndexOutOfBoundsException
- as this implementation of Term
has no argumentspublic String getName()
ListFactory.LIST_PREDICATE_NAME
.getName
in interface Term
ListFactory.LIST_PREDICATE_NAME
public TermType getType()
TermType.EMPTY_LIST
.getType
in interface Term
TermType.EMPTY_LIST
public boolean unify(Term t)
Term
The rules for deciding if two terms are unifiable are as follows:
Variable
will unify with any term. As a result the Variable
will become
instantiated to the other term. The instantiaton will be undone when Term.backtrack()
is next called on the
Variable
TermType
and have the same value.
The exact meaning of "having the same value" will vary between term types but will include that the two terms
being unified have the same number of arguments and that all of their corresponding arguments unify.unify
in interface Term
t
- the term to unify this term againsttrue
if the attempt to unify this term to the given term was successfulTerm.backtrack()
Copyright © 2024. All rights reserved.