avail/avail.dispatch/LookupTreeAdaptor

LookupTreeAdaptor

abstract class LookupTreeAdaptor<Element : A_BasicObject, Result : A_BasicObject, Memento>

LookupTreeAdaptor is instantiated to construct and interpret a family of type-dispatch trees.

Author

Mark van Gulik

Parameters

Element

The kind of elements in the lookup tree, such as method definitions.

Result

What we expect to produce from a lookup activity, such as the tuple of most-specific matching method definitions for some arguments.

Memento

A memento to supply arbitrary additional information.

Inheritors

ParserTypeChecker

Constructors

LookupTreeAdaptor

constructor()

Types

Companion

object Companion

Properties

emptyLeaf

abstract val emptyLeaf: LeafLookupTree<Element, Result>

A lightweight leaf node that can be used to indicate a negative search (i.e., no elements were applicable).

Functions

compareTypes

abstract fun compareTypes(argumentRestrictions: List<TypeRestriction>, signatureType: A_Type): TypeComparison

Compare two types to produce a TypeComparison.

constructResult

abstract fun constructResult(elements: List<Element>, memento: Memento): Result

Construct a Result from a List of Elements.

createRoot

fun createRoot(allElements: Collection<Element>, knownArgumentRestrictions: List<TypeRestriction>, memento: Memento): LookupTree<Element, Result>

Create a LookupTree, using the provided collection of Elements, and the list of initial argument types.

extractBoundingType

fun extractBoundingType(argumentRestrictions: List<TypeRestriction>): A_Type

Compute the bounding signature from the given List of TypeRestrictions.

extractSignature

abstract fun extractSignature(element: Element): A_Type

Convert from an Element to a suitable A_Type for organizing the tree.

lookupByTypes

fun lookupByTypes(root: LookupTree<Element, Result>, argumentTypesTuple: A_Tuple, memento: Memento, lookupStats: LookupStatistics): Result

Use the tuple of types to traverse the tree. Answer the solution, a Result. Uses iteration rather than recursion to limit stack depth.

lookupByValue

fun lookupByValue(root: LookupTree<Element, Result>, argValue: A_BasicObject, memento: Memento, lookupStats: LookupStatistics): Result

Use the given singular value to traverse the tree. Answer the solution, a Result. Uses iteration rather than recursion to limit stack depth.

lookupByValues

fun lookupByValues(root: LookupTree<Element, Result>, argValues: List<A_BasicObject>, memento: Memento, lookupStats: LookupStatistics): Result

Given a List of A_BasicObjects, use their types to traverse the LookupTree. Answer the solution, a Result. Uses iteration rather than recursion to limit stack depth.

restrictedSignature

fun restrictedSignature(element: Element, signatureExtrasExtractor: (Element) -> Pair<A_Type?, List<A_Type>>, signatureBound: A_Type): A_Type

Extract the signature of the element, then intersect it with the given tuple type.

subtypesHideSupertypes

abstract fun subtypesHideSupertypes(): Boolean

true if Elements with more specific signatures exclude those with strictly more general signatures, false otherwise.

testsArgumentPositions

abstract fun testsArgumentPositions(): Boolean

true if the tree uses whole type testing, or false if the tree tests individual elements of a tuple type.