Package net.hydromatic.morel.compile

Class TypeResolver

java.lang.Object

net.hydromatic.morel.compile.TypeResolver

public class TypeResolver
extends Object

Resolves all the types within an expression.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	TypeResolver.BindTypeEnv	A type environment that consists of a type environment plus one binding.
private static enum	TypeResolver.CollectionType
private static class	TypeResolver.EmptySubst	Empty substitution.
(package private) static enum	TypeResolver.EmptyTypeEnv	Empty type environment.
private class	TypeResolver.EnvironmentTypeEnv	Type environment based on an Environment.
(package private) static class	TypeResolver.FieldExpander	Visitor that expands progressive types if they are used in field references.
private static class	TypeResolver.Inst	Instance of an overloaded function.
private static class	TypeResolver.KeyBuilder	Workspace for converting types to keys.
private static class	TypeResolver.PatTerm
private static class	TypeResolver.PlusSubst	Substitution that adds one (type, variable) assignment to a parent substitution.
static class	TypeResolver.Resolved	Result of validating a declaration.
(package private) static class	TypeResolver.SimpleTermFactory	Factory that always returns a given Unifier.Term.
private static class	TypeResolver.Subst	Substitution.
private static class	TypeResolver.TermVariable	Pair consisting of a term and a variable.
private static class	TypeResolver.Triple	Output of the type resolution of a from step, and input to the next step.
(package private) static interface	TypeResolver.TypeEnv	Type environment.
private class	TypeResolver.TypeEnvHolder	Contains a TypeResolver.TypeEnv and adds to it by calling TypeResolver.TypeEnv.bind(String, Kind, Function).
static class	TypeResolver.TypeException	Error while deducing type.

Field Summary

Fields

Modifier and Type	Field	Description
private final Map<Unifier.Variable,Unifier.Action>	actionMap
(package private) static final String	ARG_TY_CON
(package private) static final String	BAG_TY_CON
private final List<Unifier.Constraint>	constraints
(package private) static final String	FN_TY_CON
(package private) static final String	LIST_TY_CON
private final Map<AstNode,Unifier.Term>	map
(package private) static final String	OVERLOAD_TY_CON
private final List<TypeResolver.Inst>	overloads
private final PairList<Unifier.Variable,PrimitiveType>	preferredTypes
(package private) static final String	PROGRESSIVE_LABEL	A field of this name indicates that a record type is progressive.
(package private) static final String	RECORD_TY_CON
private final PairList<Ast.FromStep,TypeResolver.Triple>	stepStack
private final List<TypeResolver.TermVariable>	terms
(package private) static final String	TUPLE_TY_CON
private final TypeSystem	typeSystem
private final Unifier	unifier
private final List<Consumer<TypeResolver.Resolved>>	validations
private final Consumer<CompileException>	warningConsumer

Constructor Summary

Constructors

Modifier	Constructor	Description
private	TypeResolver(TypeSystem typeSystem, Consumer<CompileException> warningConsumer)

Method Summary

Modifier and Type	Method	Description
private Unifier.Sequence	argTerm(Unifier.Term... args)
private Unifier.Sequence	bagTerm(Unifier.Term term)
private static TypeResolver.TypeEnv	bindAll(TypeResolver.TypeEnv env, PairList<Ast.IdPat,Unifier.Term> termMap)
private static void	checkNoUnresolvedFieldRefs(Ast.Decl decl, TypeMap typeMap)	Checks that there are no field references "x.y" or "#y x" where "x" has an unresolved type.
private void	constrain(Unifier.Variable arg, Unifier.Variable result, PairList<Unifier.Term,Unifier.Term> argResults)	Registers that a type variable is equivalent to at least one of a list of terms.
private Ast.Exp	deduceApplyFnType(TypeResolver.TypeEnv env, Ast.Exp fn, Unifier.Variable vFn, Unifier.Variable vArg, Unifier.Variable vResult)	Deduces the datatype of a function being applied to an argument.
private Ast.Apply	deduceApplyType(TypeResolver.TypeEnv env, Ast.Apply apply, Unifier.Variable v)
private Ast.Case	deduceCaseType(TypeResolver.TypeEnv env, Ast.Case case_, Unifier.Variable v)
private void	deduceDatatypeBindType(Ast.DatatypeBind datatypeBind, PairList<String,Type.Key> tyCons)
private Ast.Decl	deduceDataTypeDeclType(TypeResolver.TypeEnv env, Ast.DatatypeDecl datatypeDecl, PairList<Ast.IdPat,Unifier.Term> termMap)
private Ast.Decl	deduceDeclType(TypeResolver.TypeEnv env, Ast.Decl node, PairList<Ast.IdPat,Unifier.Term> termMap)
private TypeResolver.Triple	deduceGroupStepType(TypeResolver.TypeEnv env, Ast.Group group, TypeResolver.Triple p, PairList<Ast.Id,Unifier.Variable> fieldVars, List<Ast.FromStep> fromSteps)
private List<Ast.Match>	deduceMatchListType(TypeResolver.TypeEnv env, List<Ast.Match> matchList, NavigableSet<String> labelNames, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Match	deduceMatchType(TypeResolver.TypeEnv env, Ast.Match match, BiConsumer<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Decl	deduceOverDeclType(TypeResolver.TypeEnv env, Ast.OverDecl overDecl, PairList<Ast.IdPat,Unifier.Term> termMap)
private void	deducePatType(TypeResolver.TypeEnv env, Ast.Pat pat, Consumer<TypeResolver.PatTerm> termMap, @Nullable NavigableSet<String> labelNames, Unifier.Variable v, UnaryOperator<Unifier.Term> accessor)	Derives a type term for a pattern, collecting the names of pattern variables.
private Ast.Query	deduceQueryType(TypeResolver.TypeEnv env, Ast.Query query, Unifier.Variable v)
private Ast.RecordSelector	deduceRecordSelectorType(TypeResolver.TypeEnv env, Ast.RecordSelector recordSelector, Unifier.Variable vArg, Unifier.Variable vResult)
private TypeResolver.Triple	deduceScanStepType(Ast.Scan scan, TypeResolver.Triple p, PairList<Ast.Id,Unifier.Variable> fieldVars, List<Ast.FromStep> fromSteps)
private TypeResolver.Triple	deduceStepType(TypeResolver.TypeEnv env, Ast.FromStep step, TypeResolver.Triple p, PairList<Ast.Id,Unifier.Variable> fieldVars, List<Ast.FromStep> fromSteps)
static TypeResolver.Resolved	deduceType(Environment env, Ast.Decl decl, TypeSystem typeSystem, Consumer<CompileException> warningConsumer)	Deduces the datatype of a declaration.
private Ast.Exp	deduceType(TypeResolver.TypeEnv env, Ast.Exp node, Unifier.Variable v)
private TypeResolver.Resolved	deduceType_(Environment env, Ast.Decl decl)	Deduces the datatype of a declaration.
private TypeResolver.Resolved	deduceTypeWithRetries(Environment env, Ast.Decl decl, TypeSystem typeSystem)	Deduces the datatype of a declaration, retrying each time a node is expanded.
private AstNode	deduceValBindType(TypeResolver.TypeEnv env, Ast.ValBind valBind, PairList<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable vPat)
private Ast.Decl	deduceValDeclType(TypeResolver.TypeEnv env, Ast.ValDecl valDecl, PairList<Ast.IdPat,Unifier.Term> termMap)
private Ast.Exp	deduceYieldType(TypeResolver.TypeEnv env, Ast.Exp node, Unifier.Variable v)	Deduces a yield expression's type.
private Unifier.Variable	equiv(Unifier.Variable v, Unifier.Term term)	Declares that a term is equivalent to a variable.
(package private) static List<String>	fieldList(Unifier.Sequence sequence)	Inverse of recordLabel(NavigableSet).
private Unifier.Variable	fieldVar(PairList<Ast.Id,Unifier.Variable> fieldVars)
private Unifier.Sequence	fnTerm(Unifier.Term arg, Unifier.Term result)
private static void	forEachUnresolvedField(Ast.Decl decl, TypeMap typeMap, Consumer<Ast.Apply> variableConsumer, Consumer<Ast.Apply> notRecordTypeConsumer, Consumer<Ast.Apply> noFieldConsumer)
private @Nullable Type	getType(TypeResolver.TypeEnv env, Ast.Exp exp)
private static Ast.Exp	idTuple(List<String> vars)	Converts a list of variable names to a variable or tuple.
private Ast.Exp	infix(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v)	Registers an infix operator.
private Ast.Exp	infix(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v, Type type)	Registers an infix operator whose type is a given type.
private void	isListIfAllAreLists(List<Unifier.Term> args, Unifier.Variable c, Unifier.Variable v)	Adds a constraint that the terms in args are all a bag or list (of v); if all are lists then c is a list of v, otherwise c is a bag of v.
private void	isListIfBothAreLists(Unifier.Term c0, Unifier.Variable v0, Unifier.Term c1, Unifier.Variable v1, Unifier.Variable c, Unifier.Variable v)	Adds a constraint that c0 is a bag or list (of v0), and c1 is a bag or list (of v1); if both are lists then c is a list of v, otherwise c is a bag of v.
private void	isListOrBagMatchingInput(Unifier.Variable c1, Unifier.Variable v1, Unifier.Variable c2, Unifier.Variable v2)	Adds a constraint that c1 is a bag or list of v1; if it is a list then c2 is a list of v2, otherwise c2 is a bag of v2.
private Unifier.Sequence	listTerm(Unifier.Term term)
private void	mayBeBagOrList(Unifier.Variable c, Unifier.Variable v)	Adds a constraint that c is a bag or list of v.
private Ast.Pat	patTuple(TypeResolver.TypeEnv env, List<Ast.Pat> patList)	Converts a list of patterns to a singleton pattern or tuple pattern.
private Ast.Exp	prefix(TypeResolver.TypeEnv env, Ast.PrefixCall call, Unifier.Variable v)	Registers a prefix operator.
(package private) static String	recordLabel(NavigableSet<String> labels)	Inverse of fieldList(Sequence).
private Unifier.Term	recordTerm(NavigableMap<String,? extends Unifier.Term> labelTypes)
private <E extends AstNode> E	reg(E node, Unifier.Term term)	Registers that an AST node maps to a type term.
private <E extends AstNode> E	reg(E node, Unifier.Variable variable, Unifier.Term term)	Registers that an AST node maps to a type term and is equivalent to a variable.
private Unifier.Term	toTerm(PrimitiveType type)
private Unifier.Term	toTerm(Type type, TypeResolver.Subst subst)
private List<Unifier.Term>	toTerms(Collection<? extends Type> types, TypeResolver.Subst subst)
private List<Unifier.Term>	toTerms(List<? extends Type> types, TypeResolver.Subst subst)
static Type	toType(Ast.Type type, TypeSystem typeSystem)	Converts a type AST to a type.
static Type.Key	toTypeKey(Ast.Type type)	Converts a type AST to a type key.
private Ast.ValBind	toValBind(TypeResolver.TypeEnv env, Ast.FunBind funBind)
private Ast.ValDecl	toValDecl(TypeResolver.TypeEnv env, Ast.FunDecl funDecl)	Converts a function declaration to a value declaration.
private Unifier.Variable	toVariable(Unifier.Term term)	Converts a term to a variable.
private Unifier.Term	tupleTerm(Collection<? extends Unifier.Term> types)
private void	validateGroup(Ast.Group group)	Validates a Group.
private void	validateOrder(Ast.Order order)	Validates an Order.

Methods inherited from class java.lang.Object

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

Field Details

typeSystem

private final TypeSystem typeSystem

warningConsumer

private final Consumer<CompileException> warningConsumer

stepStack

private final PairList<Ast.FromStep,TypeResolver.Triple> stepStack

validations

private final List<Consumer<TypeResolver.Resolved>> validations

unifier

private final Unifier unifier

terms

private final List<TypeResolver.TermVariable> terms

map

private final Map<AstNode,Unifier.Term> map

actionMap

private final Map<Unifier.Variable,Unifier.Action> actionMap

preferredTypes

private final PairList<Unifier.Variable,PrimitiveType> preferredTypes

overloads

private final List<TypeResolver.Inst> overloads

constraints

private final List<Unifier.Constraint> constraints

BAG_TY_CON

static final String BAG_TY_CON

TUPLE_TY_CON

static final String TUPLE_TY_CON

See Also:

• Constant Field Values

ARG_TY_CON

static final String ARG_TY_CON

See Also:

• Constant Field Values

OVERLOAD_TY_CON

static final String OVERLOAD_TY_CON

LIST_TY_CON

static final String LIST_TY_CON

See Also:

• Constant Field Values

RECORD_TY_CON

static final String RECORD_TY_CON

See Also:

• Constant Field Values

FN_TY_CON

static final String FN_TY_CON

See Also:

• Constant Field Values

PROGRESSIVE_LABEL

static final String PROGRESSIVE_LABEL

A field of this name indicates that a record type is progressive.

See Also:

• Constant Field Values

Constructor Details

TypeResolver

private TypeResolver(TypeSystem typeSystem,
 Consumer<CompileException> warningConsumer)

Method Details

deduceType

public static TypeResolver.Resolved deduceType(Environment env,
 Ast.Decl decl,
 TypeSystem typeSystem,
 Consumer<CompileException> warningConsumer)

Deduces the datatype of a declaration.

toType

public static Type toType(Ast.Type type,
 TypeSystem typeSystem)

Converts a type AST to a type.

toTypeKey

public static Type.Key toTypeKey(Ast.Type type)

Converts a type AST to a type key.

deduceTypeWithRetries

private TypeResolver.Resolved deduceTypeWithRetries(Environment env,
 Ast.Decl decl,
 TypeSystem typeSystem)

Deduces the datatype of a declaration, retrying each time a node is expanded.

deduceType_

private TypeResolver.Resolved deduceType_(Environment env,
 Ast.Decl decl)

Deduces the datatype of a declaration.

checkNoUnresolvedFieldRefs

private static void checkNoUnresolvedFieldRefs(Ast.Decl decl,
 TypeMap typeMap)

Checks that there are no field references "x.y" or "#y x" where "x" has an unresolved type. Throws if there are unresolved field references.

forEachUnresolvedField

private static void forEachUnresolvedField(Ast.Decl decl,
 TypeMap typeMap,
 Consumer<Ast.Apply> variableConsumer,
 Consumer<Ast.Apply> notRecordTypeConsumer,
 Consumer<Ast.Apply> noFieldConsumer)

reg

private <E extends AstNode> E reg(E node,
 Unifier.Term term)

Registers that an AST node maps to a type term.

reg

private <E extends AstNode> E reg(E node,
 Unifier.Variable variable,
 Unifier.Term term)

Registers that an AST node maps to a type term and is equivalent to a variable.

constrain

private void constrain(Unifier.Variable arg,
 Unifier.Variable result,
 PairList<Unifier.Term,Unifier.Term> argResults)

Registers that a type variable is equivalent to at least one of a list of terms.

mayBeBagOrList

private void mayBeBagOrList(Unifier.Variable c,
 Unifier.Variable v)

Adds a constraint that c is a bag or list of v.

isListOrBagMatchingInput

private void isListOrBagMatchingInput(Unifier.Variable c1,
 Unifier.Variable v1,
 Unifier.Variable c2,
 Unifier.Variable v2)

Adds a constraint that c1 is a bag or list of v1; if it is a list then c2 is a list of v2, otherwise c2 is a bag of v2.

isListIfBothAreLists

private void isListIfBothAreLists(Unifier.Term c0,
 Unifier.Variable v0,
 Unifier.Term c1,
 Unifier.Variable v1,
 Unifier.Variable c,
 Unifier.Variable v)

Adds a constraint that c0 is a bag or list (of v0), and c1 is a bag or list (of v1); if both are lists then c is a list of v, otherwise c is a bag of v.

isListIfAllAreLists

private void isListIfAllAreLists(List<Unifier.Term> args,
 Unifier.Variable c,
 Unifier.Variable v)

Adds a constraint that the terms in args are all a bag or list (of v); if all are lists then c is a list of v, otherwise c is a bag of v.

deduceYieldType

private Ast.Exp deduceYieldType(TypeResolver.TypeEnv env,
 Ast.Exp node,
 Unifier.Variable v)

Deduces a yield expression's type.

Singleton records are treated specially. The type of yield {x = y} is not a record type but the type of y. The step has the same effect as yield y, except that it introduces x into the namespace.

deduceType

private Ast.Exp deduceType(TypeResolver.TypeEnv env,
 Ast.Exp node,
 Unifier.Variable v)

deduceQueryType

private Ast.Query deduceQueryType(TypeResolver.TypeEnv env,
 Ast.Query query,
 Unifier.Variable v)

deduceStepType

private TypeResolver.Triple deduceStepType(TypeResolver.TypeEnv env,
 Ast.FromStep step,
 TypeResolver.Triple p,
 PairList<Ast.Id,Unifier.Variable> fieldVars,
 List<Ast.FromStep> fromSteps)

deduceScanStepType

private TypeResolver.Triple deduceScanStepType(Ast.Scan scan,
 TypeResolver.Triple p,
 PairList<Ast.Id,Unifier.Variable> fieldVars,
 List<Ast.FromStep> fromSteps)

argTerm

private Unifier.Sequence argTerm(Unifier.Term... args)

deduceGroupStepType

private TypeResolver.Triple deduceGroupStepType(TypeResolver.TypeEnv env,
 Ast.Group group,
 TypeResolver.Triple p,
 PairList<Ast.Id,Unifier.Variable> fieldVars,
 List<Ast.FromStep> fromSteps)

validateGroup

private void validateGroup(Ast.Group group)

Validates a Group. Throws if there are duplicate names among the keys and aggregates.

validateOrder

private void validateOrder(Ast.Order order)

Validates an Order. Warns if asked so sort on a record expression where the fields are not in alphabetical order.

fieldVar

private Unifier.Variable fieldVar(PairList<Ast.Id,Unifier.Variable> fieldVars)

deduceApplyType

private Ast.Apply deduceApplyType(TypeResolver.TypeEnv env,
 Ast.Apply apply,
 Unifier.Variable v)

deduceApplyFnType

private Ast.Exp deduceApplyFnType(TypeResolver.TypeEnv env,
 Ast.Exp fn,
 Unifier.Variable vFn,
 Unifier.Variable vArg,
 Unifier.Variable vResult)

Deduces the datatype of a function being applied to an argument. If the function is overloaded, the argument will help us resolve the overloading.

Parameters:

env - Compile-time environment

fn - Function expression (often an identifier)

vFn - Variable for the function type

vArg - Variable for the argument type

vResult - Variable for the result type

Returns:

the function expression with its type deduced

getType

private @Nullable Type getType(TypeResolver.TypeEnv env,
 Ast.Exp exp)

deduceRecordSelectorType

private Ast.RecordSelector deduceRecordSelectorType(TypeResolver.TypeEnv env,
 Ast.RecordSelector recordSelector,
 Unifier.Variable vArg,
 Unifier.Variable vResult)

fieldList

static List<String> fieldList(Unifier.Sequence sequence)

Inverse of recordLabel(NavigableSet).

recordLabel

static String recordLabel(NavigableSet<String> labels)

Inverse of fieldList(Sequence).

deduceMatchType

private Ast.Match deduceMatchType(TypeResolver.TypeEnv env,
 Ast.Match match,
 BiConsumer<Ast.IdPat,Unifier.Term> termMap,
 Unifier.Variable argVariable,
 Unifier.Variable resultVariable)

deduceMatchListType

private List<Ast.Match> deduceMatchListType(TypeResolver.TypeEnv env,
 List<Ast.Match> matchList,
 NavigableSet<String> labelNames,
 Unifier.Variable argVariable,
 Unifier.Variable resultVariable)

deduceCaseType

private Ast.Case deduceCaseType(TypeResolver.TypeEnv env,
 Ast.Case case_,
 Unifier.Variable v)

deduceValBindType

private AstNode deduceValBindType(TypeResolver.TypeEnv env,
 Ast.ValBind valBind,
 PairList<Ast.IdPat,Unifier.Term> termMap,
 Unifier.Variable vPat)

bindAll

private static TypeResolver.TypeEnv bindAll(TypeResolver.TypeEnv env,
 PairList<Ast.IdPat,Unifier.Term> termMap)

deduceDeclType

private Ast.Decl deduceDeclType(TypeResolver.TypeEnv env,
 Ast.Decl node,
 PairList<Ast.IdPat,Unifier.Term> termMap)

deduceDataTypeDeclType

private Ast.Decl deduceDataTypeDeclType(TypeResolver.TypeEnv env,
 Ast.DatatypeDecl datatypeDecl,
 PairList<Ast.IdPat,Unifier.Term> termMap)

deduceOverDeclType

private Ast.Decl deduceOverDeclType(TypeResolver.TypeEnv env,
 Ast.OverDecl overDecl,
 PairList<Ast.IdPat,Unifier.Term> termMap)

deduceValDeclType

private Ast.Decl deduceValDeclType(TypeResolver.TypeEnv env,
 Ast.ValDecl valDecl,
 PairList<Ast.IdPat,Unifier.Term> termMap)

deduceDatatypeBindType

private void deduceDatatypeBindType(Ast.DatatypeBind datatypeBind,
 PairList<String,Type.Key> tyCons)

toValDecl

private Ast.ValDecl toValDecl(TypeResolver.TypeEnv env,
 Ast.FunDecl funDecl)

Converts a function declaration to a value declaration. In other words, fun is syntactic sugar, and this is the de-sugaring machine.

For example, fun inc x = x + 1 becomes val rec inc = fn x => x + 1.

If there are multiple arguments, there is one fn for each argument: fun sum x y = x + y becomes val rec sum = fn x => fn y => x + y.

If there are multiple clauses, we generate case:

 fun gcd a 0 = a | gcd a b = gcd b (a mod b)
 

becomes

val rec gcd = fn x => fn y =>
 case (x, y) of
     (a, 0) => a
   | (a, b) = gcd b (a mod b)

toValBind

private Ast.ValBind toValBind(TypeResolver.TypeEnv env,
 Ast.FunBind funBind)

idTuple

private static Ast.Exp idTuple(List<String> vars)

Converts a list of variable names to a variable or tuple.

For example, ["x"] becomes "x" (an Ast.Id), and ["x", "y"] becomes "(x, y)" (a Ast.Tuple of Ids).

patTuple

private Ast.Pat patTuple(TypeResolver.TypeEnv env,
 List<Ast.Pat> patList)

Converts a list of patterns to a singleton pattern or tuple pattern.

deducePatType

private void deducePatType(TypeResolver.TypeEnv env,
 Ast.Pat pat,
 Consumer<TypeResolver.PatTerm> termMap,
 @Nullable NavigableSet<String> labelNames,
 Unifier.Variable v,
 UnaryOperator<Unifier.Term> accessor)

Derives a type term for a pattern, collecting the names of pattern variables.

Unlike deduceType(TypeEnv, Ast.Exp, Variable), return is void, because the pattern is never modified.

Parameters:

env - Compile-time environment

pat - Pattern AST

termMap - Map from names to bound terms, populated by this method

labelNames - List of names of labels in this pattern and sibling patterns in a | match, or null if not a record pattern

v - Type variable that this method should equate the type term that it derives for this pattern

accessor - Function that, given the term for the type of the expression that this pattern is applied to, returns the type of this sub-pattern

infix

private Ast.Exp infix(TypeResolver.TypeEnv env,
 Ast.InfixCall call,
 Unifier.Variable v,
 Type type)

Registers an infix operator whose type is a given type.

infix

private Ast.Exp infix(TypeResolver.TypeEnv env,
 Ast.InfixCall call,
 Unifier.Variable v)

Registers an infix operator.

prefix

private Ast.Exp prefix(TypeResolver.TypeEnv env,
 Ast.PrefixCall call,
 Unifier.Variable v)

Registers a prefix operator.

toVariable

private Unifier.Variable toVariable(Unifier.Term term)

Converts a term to a variable.

equiv

private Unifier.Variable equiv(Unifier.Variable v,
 Unifier.Term term)

Declares that a term is equivalent to a variable.

listTerm

private Unifier.Sequence listTerm(Unifier.Term term)

bagTerm

private Unifier.Sequence bagTerm(Unifier.Term term)

fnTerm

private Unifier.Sequence fnTerm(Unifier.Term arg,
 Unifier.Term result)

recordTerm

private Unifier.Term recordTerm(NavigableMap<String,? extends Unifier.Term> labelTypes)

tupleTerm

private Unifier.Term tupleTerm(Collection<? extends Unifier.Term> types)

toTerms

private List<Unifier.Term> toTerms(List<? extends Type> types,
 TypeResolver.Subst subst)

toTerms

private List<Unifier.Term> toTerms(Collection<? extends Type> types,
 TypeResolver.Subst subst)

toTerm

private Unifier.Term toTerm(PrimitiveType type)

toTerm

private Unifier.Term toTerm(Type type,
 TypeResolver.Subst subst)