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:
objectA 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()
- 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:
objectA 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()
- 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:
objectA reference to a named type of the schema (analogous to a let-bound variable).
- NAME = Name(value='name')
- TYPE_ = Name(value='hydra.paths.NominalTypeReference')
- static builder()
- with_name(name)
- class hydra.paths.PrimitiveReference(name: Annotated[Name, 'The name of the primitive'], type: Annotated[Type, 'The type of the primitive'])
Bases:
objectA 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()
- with_name(name)
- with_type(type)
- class hydra.paths.SubtermLink(step: Annotated[SubtermStep, 'The step by which the child subterm is reached'], child: Annotated[TermNode, 'The child node (inline; the structure is a tree)'])
Bases:
objectAn 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()
- 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:
objectSubtermStepAnnotatedAnnotation | 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:
objectAccess the annotation of an annotated term
- class hydra.paths.SubtermStepAnnotatedBody
Bases:
objectAccess the body of an annotated term
- class hydra.paths.SubtermStepApplicationArgument
Bases:
objectAccess the argument of an application term
- class hydra.paths.SubtermStepApplicationFunction
Bases:
objectAccess 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:
objectAccess the default case of a case statement
- class hydra.paths.SubtermStepEitherLeft
Bases:
objectAccess the left term of an either value
- class hydra.paths.SubtermStepEitherRight
Bases:
objectAccess 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:
objectAccess 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:
objectAccess 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:
objectAccess the term inside a given (present) optional value
- class hydra.paths.SubtermStepPairFirst
Bases:
objectAccess the first term of a pair
- class hydra.paths.SubtermStepPairSecond
Bases:
objectAccess 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:
objectAccess the body of a type application term
- class hydra.paths.SubtermStepTypeLambdaBody
Bases:
objectAccess the body of a type lambda term
- class hydra.paths.SubtermStepWrapBody
Bases:
objectAccess the body of a wrapped term
- class hydra.paths.SubtypeLink(step: Annotated[SubtypeStep, 'The step by which the child subtype is reached'], child: Annotated[TypeNode, 'The child node (inline; the structure is a tree)'])
Bases:
objectAn 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()
- 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:
objectSubtypeStepAnnotatedBody | 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:
objectAccess the body of an annotated type (the annotation is a term; there is no step for it)
- class hydra.paths.SubtypeStepApplicationArgument
Bases:
objectAccess the argument of an application type
- class hydra.paths.SubtypeStepApplicationFunction
Bases:
objectAccess the function of an application type
- class hydra.paths.SubtypeStepEffectValue
Bases:
objectAccess the value type of an effect type
- class hydra.paths.SubtypeStepEitherLeft
Bases:
objectAccess the left type of an either type
- class hydra.paths.SubtypeStepEitherRight
Bases:
objectAccess the right type of an either type
- class hydra.paths.SubtypeStepForallBody
Bases:
objectAccess the body of a universally quantified type
- class hydra.paths.SubtypeStepFunctionCodomain
Bases:
objectAccess the codomain type of a function type
- class hydra.paths.SubtypeStepFunctionDomain
Bases:
objectAccess the domain type of a function type
- class hydra.paths.SubtypeStepListElement
Bases:
objectAccess the element type of a list type
- class hydra.paths.SubtypeStepMapKeys
Bases:
objectAccess the key type of a map type
- class hydra.paths.SubtypeStepMapValues
Bases:
objectAccess the value type of a map type
- class hydra.paths.SubtypeStepOptionalElement
Bases:
objectAccess the element type of an optional type
- class hydra.paths.SubtypeStepPairFirst
Bases:
objectAccess the first type of a pair type
- class hydra.paths.SubtypeStepPairSecond
Bases:
objectAccess 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:
objectAccess 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:
objectAccess the body type of a wrapped type
- class hydra.paths.TermAttributeLink
Bases:
objectTermAttributeLinkCasesTypeName | 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:
objectA 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()
- with_roots(roots)
- class hydra.paths.TermLink
Bases:
objectTermLinkAttribute | 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:
objectA 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()
- links(links)
- term(term)
- type(type)
- LINKS = Name(value='links')
- TERM = Name(value='term')
- TYPE = Name(value='type')
- TYPE_ = Name(value='hydra.paths.TermNode')
- static builder()
- with_links(links)
- 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:
objectThe 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']
- with_path(path)
- with_root(root)
- class hydra.paths.TermReference
Bases:
objectTermReferenceLambda | 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
- class hydra.paths.TermReferenceLink(step: Annotated[SubtermStep, 'The step by which the occurrence is reached'], target: Annotated[TermReference, 'The referenced binding, lambda parameter, or primitive'])
Bases:
objectAn 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
- class hydra.paths.TypeAttributeLink
Bases:
objectTypeAttributeLinkAnnotatedAnnotation | 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:
objectA 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()
- with_roots(roots)
- class hydra.paths.TypeLink
Bases:
objectTypeLinkAttribute | 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:
objectA 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()
- links(links)
- type(type)
- LINKS = Name(value='links')
- 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_links(links)
- 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:
objectThe 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']
- with_path(path)
- with_root(root)
- class hydra.paths.TypeReference
Bases:
objectTypeReferenceNominal | TypeReferenceVariable
- NOMINAL = Name(value='nominal')
- TYPE_ = Name(value='hydra.paths.TypeReference')
- VARIABLE = Name(value='variable')
- class hydra.paths.TypeReferenceLink(step: Annotated[SubtypeStep, 'The step by which the occurrence is reached'], target: Annotated[TypeReference, 'The referenced named type or type variable'])
Bases:
objectAn 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:
objectA 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()
- with_bound_by_node(bound_by_node)
- with_variable(variable)