hydra.paths module

Subterm and subtype access, and the term/type graph view of a graph.

class hydra.paths.LambdaVariableReference(variable: Annotated[Name, 'The name of the lambda-bound variable'], bound_by_node: Annotated[TermNodeId, 'The id of the node at the binding lambda'], type: Annotated[Type, 'The type of the variable'])

Bases: object

A reference to a lambda-bound variable: the node introducing it is the binding lambda.

BOUND_BY_NODE = Name(value='boundByNode')
class Builder(_variable: 'hydra.core.Name' = None, _bound_by_node: 'TermNodeId' = None, _type: 'hydra.core.Type' = None)

Bases: object

bound_by_node(bound_by_node)
build()
type(type)
variable(variable)
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.paths.LambdaVariableReference')
VARIABLE = Name(value='variable')
bound_by_node: Annotated[TermNodeId, 'The id of the node at the binding lambda']
static builder()
type: Annotated[Type, 'The type of the variable']
variable: Annotated[Name, 'The name of the lambda-bound variable']
with_bound_by_node(bound_by_node)
with_type(type)
with_variable(variable)
class hydra.paths.LetVariableReference(variable: Annotated[Name, 'The name of the let-bound variable'], binding_node: Annotated[TermNodeId, 'The id of the node at the bound term'], type: Annotated[Type, 'The type of the variable'])

Bases: object

A reference to a let-bound variable: the node introducing it is the bound term.

BINDING_NODE = Name(value='bindingNode')
class Builder(_variable: 'hydra.core.Name' = None, _binding_node: 'TermNodeId' = None, _type: 'hydra.core.Type' = None)

Bases: object

binding_node(binding_node)
build()
type(type)
variable(variable)
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.paths.LetVariableReference')
VARIABLE = Name(value='variable')
binding_node: Annotated[TermNodeId, 'The id of the node at the bound term']
static builder()
type: Annotated[Type, 'The type of the variable']
variable: Annotated[Name, 'The name of the let-bound variable']
with_binding_node(binding_node)
with_type(type)
with_variable(variable)
class hydra.paths.NominalTypeReference(name: Annotated[Name, 'The name of the referenced schema type'])

Bases: object

A reference to a named type of the schema (analogous to a let-bound variable).

class Builder(_name: 'hydra.core.Name' = None)

Bases: object

build()
name(name)
NAME = Name(value='name')
TYPE_ = Name(value='hydra.paths.NominalTypeReference')
static builder()
name: Annotated[Name, 'The name of the referenced schema type']
with_name(name)
class hydra.paths.PrimitiveReference(name: Annotated[Name, 'The name of the primitive'], type: Annotated[Type, 'The type of the primitive'])

Bases: object

A reference to a primitive function.

class Builder(_name: 'hydra.core.Name' = None, _type: 'hydra.core.Type' = None)

Bases: object

build()
name(name)
type(type)
NAME = Name(value='name')
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.paths.PrimitiveReference')
static builder()
name: Annotated[Name, 'The name of the primitive']
type: Annotated[Type, 'The type of the primitive']
with_name(name)
with_type(type)

Bases: object

An outgoing link to an immediate subterm, carried inline as a child node.

class Builder(_step: 'SubtermStep' = None, _child: 'TermNode' = None)

Bases: object

build()
child(child)
step(step)
CHILD = Name(value='child')
STEP = Name(value='step')
TYPE_ = Name(value='hydra.paths.SubtermLink')
static builder()
child: Annotated[TermNode, 'The child node (inline; the structure is a tree)']
step: Annotated[SubtermStep, 'The step by which the child subterm is reached']
with_child(child)
with_step(step)
class hydra.paths.SubtermPath(value: T)

Bases: Node[Sequence[SubtermStep]]

A sequence of subterm steps forming a path through a term, root first.

TYPE_ = Name(value='hydra.paths.SubtermPath')
class hydra.paths.SubtermStep

Bases: object

SubtermStepAnnotatedAnnotation | SubtermStepAnnotatedBody | SubtermStepApplicationArgument | SubtermStepApplicationFunction | SubtermStepCasesCase | SubtermStepCasesDefault | SubtermStepEitherLeft | SubtermStepEitherRight | SubtermStepInjectField | SubtermStepLambdaBody | SubtermStepLetBinding | SubtermStepLetBody | SubtermStepListElement | SubtermStepMapEntry | SubtermStepOptionalGiven | SubtermStepPairFirst | SubtermStepPairSecond | SubtermStepRecordField | SubtermStepSetElement | SubtermStepTypeApplicationBody | SubtermStepTypeLambdaBody | SubtermStepWrapBody

ANNOTATED_ANNOTATION = Name(value='annotatedAnnotation')
ANNOTATED_BODY = Name(value='annotatedBody')
APPLICATION_ARGUMENT = Name(value='applicationArgument')
APPLICATION_FUNCTION = Name(value='applicationFunction')
CASES_CASE = Name(value='casesCase')
CASES_DEFAULT = Name(value='casesDefault')
EITHER_LEFT = Name(value='eitherLeft')
EITHER_RIGHT = Name(value='eitherRight')
INJECT_FIELD = Name(value='injectField')
LAMBDA_BODY = Name(value='lambdaBody')
LET_BINDING = Name(value='letBinding')
LET_BODY = Name(value='letBody')
LIST_ELEMENT = Name(value='listElement')
MAP_ENTRY = Name(value='mapEntry')
OPTIONAL_GIVEN = Name(value='optionalGiven')
PAIR_FIRST = Name(value='pairFirst')
PAIR_SECOND = Name(value='pairSecond')
RECORD_FIELD = Name(value='recordField')
SET_ELEMENT = Name(value='setElement')
TYPE_ = Name(value='hydra.paths.SubtermStep')
TYPE_APPLICATION_BODY = Name(value='typeApplicationBody')
TYPE_LAMBDA_BODY = Name(value='typeLambdaBody')
WRAP_BODY = Name(value='wrapBody')
class hydra.paths.SubtermStepAnnotatedAnnotation

Bases: object

Access the annotation of an annotated term

class hydra.paths.SubtermStepAnnotatedBody

Bases: object

Access the body of an annotated term

class hydra.paths.SubtermStepApplicationArgument

Bases: object

Access the argument of an application term

class hydra.paths.SubtermStepApplicationFunction

Bases: object

Access the function of an application term

class hydra.paths.SubtermStepCasesCase(value: T)

Bases: Node[hydra.core.Name]

Access the handler of a specific case of a case statement by field name

class hydra.paths.SubtermStepCasesDefault

Bases: object

Access the default case of a case statement

class hydra.paths.SubtermStepEitherLeft

Bases: object

Access the left term of an either value

class hydra.paths.SubtermStepEitherRight

Bases: object

Access the right term of an either value

class hydra.paths.SubtermStepInjectField(value: T)

Bases: Node[hydra.core.Name]

Access the injected term of a union injection by field name

class hydra.paths.SubtermStepLambdaBody

Bases: object

Access the body of a lambda term

class hydra.paths.SubtermStepLetBinding(value: T)

Bases: Node[hydra.core.Name]

Access a specific binding in a let term by variable name

class hydra.paths.SubtermStepLetBody

Bases: object

Access the body of a let term

class hydra.paths.SubtermStepListElement(value: T)

Bases: Node[int]

Access an element of a list by index

class hydra.paths.SubtermStepMapEntry(value: T)

Bases: Node[int]

Access the map entry at the given index as a pair (k, v). Accessing this step constructs the pair; the entry is not itself a subterm occurrence, though its key and value components are, reached via pairFirst/pairSecond. Entry indexes follow the total order on serializable terms.

class hydra.paths.SubtermStepOptionalGiven

Bases: object

Access the term inside a given (present) optional value

class hydra.paths.SubtermStepPairFirst

Bases: object

Access the first term of a pair

class hydra.paths.SubtermStepPairSecond

Bases: object

Access the second term of a pair

class hydra.paths.SubtermStepRecordField(value: T)

Bases: Node[hydra.core.Name]

Access a field of a record by field name

class hydra.paths.SubtermStepSetElement(value: T)

Bases: Node[int]

Access an element of a set by index

class hydra.paths.SubtermStepTypeApplicationBody

Bases: object

Access the body of a type application term

class hydra.paths.SubtermStepTypeLambdaBody

Bases: object

Access the body of a type lambda term

class hydra.paths.SubtermStepWrapBody

Bases: object

Access the body of a wrapped term

Bases: object

An outgoing link to an immediate subtype, carried inline as a child node.

class Builder(_step: 'SubtypeStep' = None, _child: 'TypeNode' = None)

Bases: object

build()
child(child)
step(step)
CHILD = Name(value='child')
STEP = Name(value='step')
TYPE_ = Name(value='hydra.paths.SubtypeLink')
static builder()
child: Annotated[TypeNode, 'The child node (inline; the structure is a tree)']
step: Annotated[SubtypeStep, 'The step by which the child subtype is reached']
with_child(child)
with_step(step)
class hydra.paths.SubtypePath(value: T)

Bases: Node[Sequence[SubtypeStep]]

A sequence of subtype steps forming a path through a type, root first.

TYPE_ = Name(value='hydra.paths.SubtypePath')
class hydra.paths.SubtypeStep

Bases: object

SubtypeStepAnnotatedBody | SubtypeStepApplicationArgument | SubtypeStepApplicationFunction | SubtypeStepEffectValue | SubtypeStepEitherLeft | SubtypeStepEitherRight | SubtypeStepForallBody | SubtypeStepFunctionCodomain | SubtypeStepFunctionDomain | SubtypeStepListElement | SubtypeStepMapKeys | SubtypeStepMapValues | SubtypeStepOptionalElement | SubtypeStepPairFirst | SubtypeStepPairSecond | SubtypeStepRecordField | SubtypeStepSetElement | SubtypeStepUnionField | SubtypeStepWrapBody

ANNOTATED_BODY = Name(value='annotatedBody')
APPLICATION_ARGUMENT = Name(value='applicationArgument')
APPLICATION_FUNCTION = Name(value='applicationFunction')
EFFECT_VALUE = Name(value='effectValue')
EITHER_LEFT = Name(value='eitherLeft')
EITHER_RIGHT = Name(value='eitherRight')
FORALL_BODY = Name(value='forallBody')
FUNCTION_CODOMAIN = Name(value='functionCodomain')
FUNCTION_DOMAIN = Name(value='functionDomain')
LIST_ELEMENT = Name(value='listElement')
MAP_KEYS = Name(value='mapKeys')
MAP_VALUES = Name(value='mapValues')
OPTIONAL_ELEMENT = Name(value='optionalElement')
PAIR_FIRST = Name(value='pairFirst')
PAIR_SECOND = Name(value='pairSecond')
RECORD_FIELD = Name(value='recordField')
SET_ELEMENT = Name(value='setElement')
TYPE_ = Name(value='hydra.paths.SubtypeStep')
UNION_FIELD = Name(value='unionField')
WRAP_BODY = Name(value='wrapBody')
class hydra.paths.SubtypeStepAnnotatedBody

Bases: object

Access the body of an annotated type (the annotation is a term; there is no step for it)

class hydra.paths.SubtypeStepApplicationArgument

Bases: object

Access the argument of an application type

class hydra.paths.SubtypeStepApplicationFunction

Bases: object

Access the function of an application type

class hydra.paths.SubtypeStepEffectValue

Bases: object

Access the value type of an effect type

class hydra.paths.SubtypeStepEitherLeft

Bases: object

Access the left type of an either type

class hydra.paths.SubtypeStepEitherRight

Bases: object

Access the right type of an either type

class hydra.paths.SubtypeStepForallBody

Bases: object

Access the body of a universally quantified type

class hydra.paths.SubtypeStepFunctionCodomain

Bases: object

Access the codomain type of a function type

class hydra.paths.SubtypeStepFunctionDomain

Bases: object

Access the domain type of a function type

class hydra.paths.SubtypeStepListElement

Bases: object

Access the element type of a list type

class hydra.paths.SubtypeStepMapKeys

Bases: object

Access the key type of a map type

class hydra.paths.SubtypeStepMapValues

Bases: object

Access the value type of a map type

class hydra.paths.SubtypeStepOptionalElement

Bases: object

Access the element type of an optional type

class hydra.paths.SubtypeStepPairFirst

Bases: object

Access the first type of a pair type

class hydra.paths.SubtypeStepPairSecond

Bases: object

Access the second type of a pair type

class hydra.paths.SubtypeStepRecordField(value: T)

Bases: Node[hydra.core.Name]

Access a field type of a record type by field name

class hydra.paths.SubtypeStepSetElement

Bases: object

Access the element type of a set type

class hydra.paths.SubtypeStepUnionField(value: T)

Bases: Node[hydra.core.Name]

Access a field type of a union type by field name

class hydra.paths.SubtypeStepWrapBody

Bases: object

Access the body type of a wrapped type

Bases: object

TermAttributeLinkCasesTypeName | TermAttributeLinkInjectTypeName | TermAttributeLinkLambdaDomainGiven | TermAttributeLinkLambdaParameter | TermAttributeLinkLetBindingTypeSchemeGiven | TermAttributeLinkLiteral | TermAttributeLinkProjectFieldName | TermAttributeLinkProjectTypeName | TermAttributeLinkRecordTypeName | TermAttributeLinkTypeApplicationType | TermAttributeLinkTypeLambdaParameter | TermAttributeLinkUnwrapTypeName | TermAttributeLinkWrapTypeName

CASES_TYPE_NAME = Name(value='casesTypeName')
INJECT_TYPE_NAME = Name(value='injectTypeName')
LAMBDA_DOMAIN_GIVEN = Name(value='lambdaDomainGiven')
LAMBDA_PARAMETER = Name(value='lambdaParameter')
LET_BINDING_TYPE_SCHEME_GIVEN = Name(value='letBindingTypeSchemeGiven')
LITERAL = Name(value='literal')
PROJECT_FIELD_NAME = Name(value='projectFieldName')
PROJECT_TYPE_NAME = Name(value='projectTypeName')
RECORD_TYPE_NAME = Name(value='recordTypeName')
TYPE_ = Name(value='hydra.paths.TermAttributeLink')
TYPE_APPLICATION_TYPE = Name(value='typeApplicationType')
TYPE_LAMBDA_PARAMETER = Name(value='typeLambdaParameter')
UNWRAP_TYPE_NAME = Name(value='unwrapTypeName')
WRAP_TYPE_NAME = Name(value='wrapTypeName')
class hydra.paths.TermAttributeLinkCasesTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the union type eliminated by a case statement

class hydra.paths.TermAttributeLinkInjectTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the union type of an injection

class hydra.paths.TermAttributeLinkLambdaDomainGiven(value: T)

Bases: Node[hydra.core.Type]

The (given) domain type of a lambda

class hydra.paths.TermAttributeLinkLambdaParameter(value: T)

Bases: Node[hydra.core.Name]

The parameter name of a lambda

class hydra.paths.TermAttributeLinkLetBindingTypeSchemeGiven(value: T)

Bases: Node[tuple[hydra.core.Name, hydra.core.TypeScheme]]

The name of a let binding together with its (given) type scheme

class hydra.paths.TermAttributeLinkLiteral(value: T)

Bases: Node[hydra.core.Literal]

The literal value of a literal term (a leaf)

class hydra.paths.TermAttributeLinkProjectFieldName(value: T)

Bases: Node[hydra.core.Name]

The name of the field projected by a projection

class hydra.paths.TermAttributeLinkProjectTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the record type of a projection

class hydra.paths.TermAttributeLinkRecordTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the record type of a record term

class hydra.paths.TermAttributeLinkTypeApplicationType(value: T)

Bases: Node[hydra.core.Type]

The type argument of a type application term

class hydra.paths.TermAttributeLinkTypeLambdaParameter(value: T)

Bases: Node[hydra.core.Name]

The type-variable parameter of a type lambda term

class hydra.paths.TermAttributeLinkUnwrapTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the wrapper type eliminated by an unwrap

class hydra.paths.TermAttributeLinkWrapTypeName(value: T)

Bases: Node[hydra.core.Name]

The name of the wrapper type of a wrapped term

class hydra.paths.TermGraph(roots: Annotated[Mapping[Name, TermNode], 'The root nodes, keyed by binding name'])

Bases: object

A typed graph as a term graph: one root node per binding of the graph.

class Builder(_roots: 'Mapping[hydra.core.Name, TermNode]' = None)

Bases: object

build()
roots(roots)
ROOTS = Name(value='roots')
TYPE_ = Name(value='hydra.paths.TermGraph')
static builder()
roots: Annotated[Mapping[Name, TermNode], 'The root nodes, keyed by binding name']
with_roots(roots)

Bases: object

TermLinkAttribute | TermLinkReference | TermLinkSubterm

ATTRIBUTE = Name(value='attribute')
REFERENCE = Name(value='reference')
SUBTERM = Name(value='subterm')
TYPE_ = Name(value='hydra.paths.TermLink')
class hydra.paths.TermLinkAttribute(value: T)

Bases: Node[TermAttributeLink]

A non-term constituent of this node’s term

class hydra.paths.TermLinkReference(value: T)

Bases: Node[TermReferenceLink]

A variable or primitive occurrence

class hydra.paths.TermLinkSubterm(value: T)

Bases: Node[SubtermLink]

An immediate subterm, carried inline

class hydra.paths.TermNode(term: Annotated[Term, 'The subterm as written'], type: Annotated[Type, "The subterm's type (a binding's forall type at roots), via hydra.checking"], links: Annotated[Sequence[TermLink], 'The outgoing links of the node'])

Bases: object

A node in a term graph: a subterm as written, its type, and its outgoing links.

class Builder(_term: 'hydra.core.Term' = None, _type: 'hydra.core.Type' = None, _links: 'Sequence[TermLink]' = None)

Bases: object

build()
term(term)
type(type)
TERM = Name(value='term')
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.paths.TermNode')
static builder()
term: Annotated[Term, 'The subterm as written']
type: Annotated[Type, "The subterm's type (a binding's forall type at roots), via hydra.checking"]
with_term(term)
with_type(type)
class hydra.paths.TermNodeId(root: Annotated[Name, 'The name of the root binding'], path: Annotated[SubtermPath, 'The subterm path from the root'])

Bases: object

The id of a term-graph node: a root binding name plus a subterm path from that root. A root node’s id has an empty path. A letBinding step appears only for an actual nested let inside a binding’s term, never as a leading pseudo-step.

class Builder(_root: 'hydra.core.Name' = None, _path: 'SubtermPath' = None)

Bases: object

build()
path(path)
root(root)
PATH = Name(value='path')
ROOT = Name(value='root')
TYPE_ = Name(value='hydra.paths.TermNodeId')
static builder()
path: Annotated[SubtermPath, 'The subterm path from the root']
root: Annotated[Name, 'The name of the root binding']
with_path(path)
with_root(root)
class hydra.paths.TermReference

Bases: object

TermReferenceLambda | TermReferenceLet | TermReferencePrimitive

LAMBDA = Name(value='lambda')
LET = Name(value='let')
PRIMITIVE = Name(value='primitive')
TYPE_ = Name(value='hydra.paths.TermReference')
class hydra.paths.TermReferenceLambda(value: T)

Bases: Node[LambdaVariableReference]

A reference to a lambda-bound variable

class hydra.paths.TermReferenceLet(value: T)

Bases: Node[LetVariableReference]

A reference to a let-bound variable

Bases: object

An outgoing link to a variable or primitive occurrence.

class Builder(_step: 'SubtermStep' = None, _target: 'TermReference' = None)

Bases: object

build()
step(step)
target(target)
STEP = Name(value='step')
TARGET = Name(value='target')
TYPE_ = Name(value='hydra.paths.TermReferenceLink')
static builder()
step: Annotated[SubtermStep, 'The step by which the occurrence is reached']
target: Annotated[TermReference, 'The referenced binding, lambda parameter, or primitive']
with_step(step)
with_target(target)
class hydra.paths.TermReferencePrimitive(value: T)

Bases: Node[PrimitiveReference]

A reference to a primitive function

Bases: object

TypeAttributeLinkAnnotatedAnnotation | TypeAttributeLinkForallParameter | TypeAttributeLinkLiteral

ANNOTATED_ANNOTATION = Name(value='annotatedAnnotation')
FORALL_PARAMETER = Name(value='forallParameter')
LITERAL = Name(value='literal')
TYPE_ = Name(value='hydra.paths.TypeAttributeLink')
class hydra.paths.TypeAttributeLinkAnnotatedAnnotation(value: T)

Bases: Node[hydra.core.Term]

The annotation of an annotated type (a term; not descended into)

class hydra.paths.TypeAttributeLinkForallParameter(value: T)

Bases: Node[hydra.core.Name]

The type-variable parameter of a universally quantified type

class hydra.paths.TypeAttributeLinkLiteral(value: T)

Bases: Node[hydra.core.LiteralType]

The literal type of a literal type (a leaf)

class hydra.paths.TypeGraph(roots: Annotated[Mapping[Name, TypeNode], 'The root nodes, keyed by type name'])

Bases: object

A schema as a type graph: one root node per named type.

class Builder(_roots: 'Mapping[hydra.core.Name, TypeNode]' = None)

Bases: object

build()
roots(roots)
ROOTS = Name(value='roots')
TYPE_ = Name(value='hydra.paths.TypeGraph')
static builder()
roots: Annotated[Mapping[Name, TypeNode], 'The root nodes, keyed by type name']
with_roots(roots)

Bases: object

TypeLinkAttribute | TypeLinkReference | TypeLinkSubtype

ATTRIBUTE = Name(value='attribute')
REFERENCE = Name(value='reference')
SUBTYPE = Name(value='subtype')
TYPE_ = Name(value='hydra.paths.TypeLink')
class hydra.paths.TypeLinkAttribute(value: T)

Bases: Node[TypeAttributeLink]

A non-type constituent of this node’s type

class hydra.paths.TypeLinkReference(value: T)

Bases: Node[TypeReferenceLink]

A named-type or type-variable occurrence

class hydra.paths.TypeLinkSubtype(value: T)

Bases: Node[SubtypeLink]

An immediate subtype, carried inline

class hydra.paths.TypeNode(type: Annotated[Type, 'The subtype as written (needed for linkless leaves: literal types, unit, void)'], links: Annotated[Sequence[TypeLink], 'The outgoing links of the node'])

Bases: object

A node in a type graph: a subtype as written and its outgoing links.

class Builder(_type: 'hydra.core.Type' = None, _links: 'Sequence[TypeLink]' = None)

Bases: object

build()
type(type)
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.paths.TypeNode')
static builder()
type: Annotated[Type, 'The subtype as written (needed for linkless leaves: literal types, unit, void)']
with_type(type)
class hydra.paths.TypeNodeId(root: Annotated[Name, 'The name of the root type'], path: Annotated[SubtypePath, 'The subtype path from the root'])

Bases: object

The id of a type-graph node: a root type name plus a subtype path from that root. A root node’s id has an empty path. There is no enclosing-let analog for schemas.

class Builder(_root: 'hydra.core.Name' = None, _path: 'SubtypePath' = None)

Bases: object

build()
path(path)
root(root)
PATH = Name(value='path')
ROOT = Name(value='root')
TYPE_ = Name(value='hydra.paths.TypeNodeId')
static builder()
path: Annotated[SubtypePath, 'The subtype path from the root']
root: Annotated[Name, 'The name of the root type']
with_path(path)
with_root(root)
class hydra.paths.TypeReference

Bases: object

TypeReferenceNominal | TypeReferenceVariable

NOMINAL = Name(value='nominal')
TYPE_ = Name(value='hydra.paths.TypeReference')
VARIABLE = Name(value='variable')

Bases: object

An outgoing link to a named-type or type-variable occurrence.

class Builder(_step: 'SubtypeStep' = None, _target: 'TypeReference' = None)

Bases: object

build()
step(step)
target(target)
STEP = Name(value='step')
TARGET = Name(value='target')
TYPE_ = Name(value='hydra.paths.TypeReferenceLink')
static builder()
step: Annotated[SubtypeStep, 'The step by which the occurrence is reached']
target: Annotated[TypeReference, 'The referenced named type or type variable']
with_step(step)
with_target(target)
class hydra.paths.TypeReferenceNominal(value: T)

Bases: Node[NominalTypeReference]

A reference to a named type of the schema

class hydra.paths.TypeReferenceVariable(value: T)

Bases: Node[TypeVariableReference]

A reference to a forall-bound type variable

class hydra.paths.TypeVariableReference(variable: Annotated[Name, 'The name of the forall-bound type variable'], bound_by_node: Annotated[TypeNodeId, 'The id of the node at the binding forall'])

Bases: object

A reference to a forall-bound type variable: the node introducing it is the binder.

BOUND_BY_NODE = Name(value='boundByNode')
class Builder(_variable: 'hydra.core.Name' = None, _bound_by_node: 'TypeNodeId' = None)

Bases: object

bound_by_node(bound_by_node)
build()
variable(variable)
TYPE_ = Name(value='hydra.paths.TypeVariableReference')
VARIABLE = Name(value='variable')
bound_by_node: Annotated[TypeNodeId, 'The id of the node at the binding forall']
static builder()
variable: Annotated[Name, 'The name of the forall-bound type variable']
with_bound_by_node(bound_by_node)
with_variable(variable)