Package net.hydromatic.morel.util

Class Unifier

java.lang.Object

net.hydromatic.morel.util.Unifier

Direct Known Subclasses:

MartelliUnifier, RobinsonUnifier

public abstract class Unifier
extends Object

Given pairs of terms, finds a substitution to minimize those pairs of terms.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	Unifier.Action	Called by the unifier when a Term's type becomes known.
static final class	Unifier.Constraint	Constraint arising from a call to an overloaded function.
static class	Unifier.CycleException	Control flow exception, thrown by Unifier.Term.checkCycle(Map, Map) if it finds a cycle in a substitution map.
private static class	Unifier.EquivAction	An action that, when executed, marks two terms as equivalent.
static interface	Unifier.Failure	Result indicating that unification was not possible.
static interface	Unifier.Result	Result of attempting unification.
static interface	Unifier.Retry	Result indicating that unification may be possible if we adjust some initial parameters.
static final class	Unifier.Sequence	A sequence of terms.
static class	Unifier.Substitution	Map from variables to terms.
static final class	Unifier.SubstitutionResult	The results of a successful unification.
static interface	Unifier.Term	Term (variable, symbol or node).
static final class	Unifier.TermTerm	A pair of terms.
static interface	Unifier.TermVisitor<R>	Visitor for terms.
static interface	Unifier.Tracer	Called on various events during unification.
static final class	Unifier.Variable	A variable that represents a symbol or a sequence; unification's task is to find the substitutions for such variables.

Field Summary

Fields

Modifier and Type	Field	Description
private final Map<String,Unifier.Sequence>	atomMap
private final Map<String,AtomicInteger>	nameMap	Assists with the generation of unique names by recording the lowest ordinal, for a given prefix, for which a name has not yet been generated.
private final Map<String,Unifier.Sequence>	sequenceMap
private final Map<String,Unifier.Variable>	variableMap

Constructor Summary

Constructors

Constructor	Description
Unifier()

Method Summary

Modifier and Type	Method	Description
Unifier.Sequence	apply(String operator, Iterable<? extends Unifier.Term> args)	Creates a sequence, or returns an existing one with the same terms.
Unifier.Sequence	apply(String operator, Unifier.Term... args)	Creates a sequence, or returns an existing one with the same terms.
Unifier.Term	atom(String name)	Creates an atom, or returns an existing one with the same name.
Unifier.Term	atomUnique(String prefix)	Creates an atom with a unique name.
private static void	checkCycles(Map<Unifier.Variable,Unifier.Term> map, Map<Unifier.Variable,Unifier.Variable> active)
Unifier.Constraint	constraint(Unifier.Variable arg, PairList<Unifier.Term,Unifier.Constraint.Action> termActions)	Creates a Constraint.
Unifier.Constraint	constraint(Unifier.Variable arg, Unifier.Variable result, PairList<Unifier.Term,Unifier.Term> argResults)	Creates a constraint arising from a call to an overloaded function.
protected Unifier.Failure	failure(String reason)
private <T> T	newName(String prefix, BiFunction<String,Integer,T> consumer)	Finds an ordinal that makes a name unique among atomcs and variables.
boolean	occurs()	Whether this unifier checks for cycles in substitutions.
(package private) static Unifier.Sequence	sequenceApply(String operator, Map<Unifier.Variable,Unifier.Term> substitutions, Iterable<Unifier.Term> terms)
Unifier.Substitution	substitution(Unifier.Term... varTerms)	Creates a substitution.
abstract @NonNull Unifier.Result	unify(List<Unifier.TermTerm> termPairs, Map<Unifier.Variable,Unifier.Action> termActions, List<Unifier.Constraint> constraints, Unifier.Tracer tracer)
Unifier.Variable	variable()	Creates a new variable, with a new name.
Unifier.Variable	variable(int ordinal)	Creates a variable, or returns an existing one with the same ordinal.
Unifier.Variable	variable(String name)	Creates a variable, or returns an existing one with the same name.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

variableMap

private final Map<String,Unifier.Variable> variableMap

atomMap

private final Map<String,Unifier.Sequence> atomMap

sequenceMap

private final Map<String,Unifier.Sequence> sequenceMap

nameMap

private final Map<String,AtomicInteger> nameMap

Assists with the generation of unique names by recording the lowest ordinal, for a given prefix, for which a name has not yet been generated.

For example, if we have called name("T") twice, and thereby generated "T0" and "T1, then the map will contain code("T", 2), indicating that the next call to name("T") should generate "T2".

Constructor Details

Unifier

public Unifier()

Method Details

occurs

public boolean occurs()

Whether this unifier checks for cycles in substitutions.

apply

public Unifier.Sequence apply(String operator,
 Unifier.Term... args)

Creates a sequence, or returns an existing one with the same terms.

apply

public Unifier.Sequence apply(String operator,
 Iterable<? extends Unifier.Term> args)

Creates a sequence, or returns an existing one with the same terms.

variable

public Unifier.Variable variable(String name)

Creates a variable, or returns an existing one with the same name.

variable

public Unifier.Variable variable(int ordinal)

Creates a variable, or returns an existing one with the same ordinal.

variable

public Unifier.Variable variable()

Creates a new variable, with a new name.

atom

public Unifier.Term atom(String name)

Creates an atom, or returns an existing one with the same name.

constraint

public Unifier.Constraint constraint(Unifier.Variable arg,
 Unifier.Variable result,
 PairList<Unifier.Term,Unifier.Term> argResults)

Creates a constraint arising from a call to an overloaded function.

Consider a call to an overloaded function with two overloads c -> d and e -> f. If the argument (a) unifies to c then the result (b) is d; if the argument unifies to e then the result is f.

This is created with the following call:

 Constraint constraint =
   unifier.constraint(a, b, PairList.of(c, d, e, f));
 

constraint

public Unifier.Constraint constraint(Unifier.Variable arg,
 PairList<Unifier.Term,Unifier.Constraint.Action> termActions)

Creates a Constraint.

The following code creates a constraint where a is allowed to be either term1 or term2. When the unifier has narrowed down the options to just term2, it will call action2 with a consumer that accepts a pair of Unifier.Term arguments.

 Constraint constraint =
   unifier.constraint(a, PairList.of(term1, action1, term2, action2));
 

atomUnique

public Unifier.Term atomUnique(String prefix)

Creates an atom with a unique name.

newName

private <T> T newName(String prefix,
 BiFunction<String,Integer,T> consumer)

Finds an ordinal that makes a name unique among atomcs and variables.

substitution

public Unifier.Substitution substitution(Unifier.Term... varTerms)

Creates a substitution.

The arguments are alternating variable / term pairs. For example, substitution(a, x, b, y) becomes [a/X, b/Y].

sequenceApply

static Unifier.Sequence sequenceApply(String operator,
 Map<Unifier.Variable,Unifier.Term> substitutions,
 Iterable<Unifier.Term> terms)

unify

public abstract @NonNull Unifier.Result unify(List<Unifier.TermTerm> termPairs,
 Map<Unifier.Variable,Unifier.Action> termActions,
 List<Unifier.Constraint> constraints,
 Unifier.Tracer tracer)

checkCycles

private static void checkCycles(Map<Unifier.Variable,Unifier.Term> map,
 Map<Unifier.Variable,Unifier.Variable> active)
                         throws Unifier.CycleException

Throws:

Unifier.CycleException

failure

protected Unifier.Failure failure(String reason)