hydra.error.core module

Error types for core type and term validation.

class hydra.error.core.ConstantConditionError(location: Annotated[SubtermPath, 'The path to the constant condition within the term'], value: Annotated[bool, 'The constant boolean value of the condition'])

Bases: object

An application of ifElse where the condition is a literal boolean, creating a dead branch (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _value: 'bool' = None)

Bases: object

build()

location(location)

value(value)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.ConstantConditionError')

VALUE = Name(value='value')

static builder()

location: Annotated[SubtermPath, 'The path to the constant condition within the term']

value: Annotated[bool, 'The constant boolean value of the condition']

with_location(location)

with_value(value)

class hydra.error.core.DuplicateBindingError(location: Annotated[SubtermPath, 'The path to the duplicate binding within the term'], name: Annotated[Name, 'The duplicated binding name'])

Bases: object

A duplicate binding name in a let expression.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.DuplicateBindingError')

static builder()

location: Annotated[SubtermPath, 'The path to the duplicate binding within the term']

name: Annotated[Name, 'The duplicated binding name']

with_location(location)

with_name(name)

class hydra.error.core.DuplicateFieldError(location: Annotated[SubtermPath, 'The path to the duplicate field within the term'], name: Annotated[Name, 'The duplicated field name'])

Bases: object

A duplicate field name in a record or union type.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.DuplicateFieldError')

static builder()

location: Annotated[SubtermPath, 'The path to the duplicate field within the term']

name: Annotated[Name, 'The duplicated field name']

with_location(location)

with_name(name)

class hydra.error.core.DuplicateRecordTypeFieldNamesError(location: Annotated[SubtermPath, 'The path to the record type with duplicate fields'], name: Annotated[Name, 'The duplicated field name'])

Bases: object

A record type with duplicate field names.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.DuplicateRecordTypeFieldNamesError')

static builder()

location: Annotated[SubtermPath, 'The path to the record type with duplicate fields']

name: Annotated[Name, 'The duplicated field name']

with_location(location)

with_name(name)

class hydra.error.core.DuplicateUnionTypeFieldNamesError(location: Annotated[SubtermPath, 'The path to the union type with duplicate fields'], name: Annotated[Name, 'The duplicated field name'])

Bases: object

A union type with duplicate field names.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.DuplicateUnionTypeFieldNamesError')

static builder()

location: Annotated[SubtermPath, 'The path to the union type with duplicate fields']

name: Annotated[Name, 'The duplicated field name']

with_location(location)

with_name(name)

class hydra.error.core.EmptyCaseStatementError(location: Annotated[SubtermPath, 'The path to the empty case statement within the term'], type_name: Annotated[Name, 'The name of the union type being matched'])

Bases: object

A case statement with no cases and no default (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

type_name(type_name)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyCaseStatementError')

TYPE_NAME = Name(value='typeName')

static builder()

location: Annotated[SubtermPath, 'The path to the empty case statement within the term']

type_name: Annotated[Name, 'The name of the union type being matched']

with_location(location)

with_type_name(type_name)

class hydra.error.core.EmptyLetBindingsError(location: Annotated[SubtermPath, 'The path to the empty let expression within the term'])

Bases: object

A let expression with an empty list of bindings (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyLetBindingsError')

static builder()

location: Annotated[SubtermPath, 'The path to the empty let expression within the term']

with_location(location)

class hydra.error.core.EmptyRecordTypeError(location: Annotated[SubtermPath, 'The path to the empty record type'])

Bases: object

A record type with no fields; TypeUnit is preferred for the unit-like case (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyRecordTypeError')

static builder()

location: Annotated[SubtermPath, 'The path to the empty record type']

with_location(location)

class hydra.error.core.EmptyTermAnnotationError(location: Annotated[SubtermPath, 'The path to the empty annotation within the term'])

Bases: object

A term annotation with an empty annotation map (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyTermAnnotationError')

static builder()

location: Annotated[SubtermPath, 'The path to the empty annotation within the term']

with_location(location)

class hydra.error.core.EmptyTypeAnnotationError(location: Annotated[SubtermPath, 'The path to the empty annotation'])

Bases: object

A type annotation with an empty annotation map (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyTypeAnnotationError')

static builder()

location: Annotated[SubtermPath, 'The path to the empty annotation']

with_location(location)

class hydra.error.core.EmptyTypeNameInTermError(location: Annotated[SubtermPath, 'The path to the term with the empty type name'])

Bases: object

A record, injection, projection, or case statement with an empty type name (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyTypeNameInTermError')

static builder()

location: Annotated[SubtermPath, 'The path to the term with the empty type name']

with_location(location)

class hydra.error.core.EmptyUnionTypeError(location: Annotated[SubtermPath, 'The path to the empty union type'])

Bases: object

A union type with no alternatives; TypeVoid is preferred (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.EmptyUnionTypeError')

static builder()

location: Annotated[SubtermPath, 'The path to the empty union type']

with_location(location)

class hydra.error.core.ExtraRecordFieldsError(location: Annotated[SubtermPath, 'The path to the record term within the term'], type_name: Annotated[Name, 'The name of the record type'], field_names: Annotated[Sequence[Name], 'The names of the undeclared fields supplied by the record term'])

Bases: object

A record term supplying a field that its record type does not declare.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _field_names: 'Sequence[hydra.core.Name]' = None)

Bases: object

build()

field_names(field_names)

location(location)

type_name(type_name)

FIELD_NAMES = Name(value='fieldNames')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.ExtraRecordFieldsError')

TYPE_NAME = Name(value='typeName')

static builder()

field_names: Annotated[Sequence[Name], 'The names of the undeclared fields supplied by the record term']

location: Annotated[SubtermPath, 'The path to the record term within the term']

type_name: Annotated[Name, 'The name of the record type']

with_field_names(field_names)

with_location(location)

with_type_name(type_name)

class hydra.error.core.InvalidForallParameterNameError(location: Annotated[SubtermPath, 'The path to the forall type'], name: Annotated[Name, 'The invalid parameter name'])

Bases: object

A forall type parameter name that violates type variable naming conventions (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.InvalidForallParameterNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the forall type']

name: Annotated[Name, 'The invalid parameter name']

with_location(location)

with_name(name)

class hydra.error.core.InvalidLambdaParameterNameError(location: Annotated[SubtermPath, 'The path to the lambda within the term'], name: Annotated[Name, 'The invalid parameter name'])

Bases: object

A lambda parameter name that violates naming conventions (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.InvalidLambdaParameterNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the lambda within the term']

name: Annotated[Name, 'The invalid parameter name']

with_location(location)

with_name(name)

class hydra.error.core.InvalidLetBindingNameError(location: Annotated[SubtermPath, 'The path to the binding within the term'], name: Annotated[Name, 'The invalid binding name'])

Bases: object

A let binding name that violates naming conventions (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.InvalidLetBindingNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the binding within the term']

name: Annotated[Name, 'The invalid binding name']

with_location(location)

with_name(name)

class hydra.error.core.InvalidLiteralError

Bases: object

InvalidLiteralErrorTypeMismatch

TYPE_ = Name(value='hydra.error.core.InvalidLiteralError')

TYPE_MISMATCH = Name(value='typeMismatch')

class hydra.error.core.InvalidLiteralErrorTypeMismatch(value: T)

Bases: Node[LiteralTypeMismatchError]

The literal’s type does not match the expected literal type

class hydra.error.core.InvalidTermError

Bases: object

InvalidTermErrorConstantCondition | InvalidTermErrorDuplicateBinding | InvalidTermErrorDuplicateField | InvalidTermErrorEmptyCaseStatement | InvalidTermErrorEmptyLetBindings | InvalidTermErrorEmptyTermAnnotation | InvalidTermErrorEmptyTypeNameInTerm | InvalidTermErrorExtraRecordFields | InvalidTermErrorInvalidLambdaParameterName | InvalidTermErrorInvalidLetBindingName | InvalidTermErrorInvalidTypeLambdaParameterName | InvalidTermErrorMissingCaseBranches | InvalidTermErrorMissingRecordFields | InvalidTermErrorNestedTermAnnotation | InvalidTermErrorNominalTypeKindMismatch | InvalidTermErrorRedundantWrapUnwrap | InvalidTermErrorSelfApplication | InvalidTermErrorTermVariableShadowing | InvalidTermErrorTypeVariableShadowingInTypeLambda | InvalidTermErrorUndeclaredVariant | InvalidTermErrorUndefinedTermVariable | InvalidTermErrorUndefinedTypeVariableInBindingType | InvalidTermErrorUndefinedTypeVariableInLambdaDomain | InvalidTermErrorUndefinedTypeVariableInTypeApplication | InvalidTermErrorUnknownCaseAlternative | InvalidTermErrorUnknownPrimitiveName | InvalidTermErrorUnknownProjectedField | InvalidTermErrorUnnecessaryIdentityApplication | InvalidTermErrorUnresolvedNominalType | InvalidTermErrorUntypedTermVariable

CONSTANT_CONDITION = Name(value='constantCondition')

DUPLICATE_BINDING = Name(value='duplicateBinding')

DUPLICATE_FIELD = Name(value='duplicateField')

EMPTY_CASE_STATEMENT = Name(value='emptyCaseStatement')

EMPTY_LET_BINDINGS = Name(value='emptyLetBindings')

EMPTY_TERM_ANNOTATION = Name(value='emptyTermAnnotation')

EMPTY_TYPE_NAME_IN_TERM = Name(value='emptyTypeNameInTerm')

EXTRA_RECORD_FIELDS = Name(value='extraRecordFields')

INVALID_LAMBDA_PARAMETER_NAME = Name(value='invalidLambdaParameterName')

INVALID_LET_BINDING_NAME = Name(value='invalidLetBindingName')

INVALID_TYPE_LAMBDA_PARAMETER_NAME = Name(value='invalidTypeLambdaParameterName')

MISSING_CASE_BRANCHES = Name(value='missingCaseBranches')

MISSING_RECORD_FIELDS = Name(value='missingRecordFields')

NESTED_TERM_ANNOTATION = Name(value='nestedTermAnnotation')

NOMINAL_TYPE_KIND_MISMATCH = Name(value='nominalTypeKindMismatch')

REDUNDANT_WRAP_UNWRAP = Name(value='redundantWrapUnwrap')

SELF_APPLICATION = Name(value='selfApplication')

TERM_VARIABLE_SHADOWING = Name(value='termVariableShadowing')

TYPE_ = Name(value='hydra.error.core.InvalidTermError')

TYPE_VARIABLE_SHADOWING_IN_TYPE_LAMBDA = Name(value='typeVariableShadowingInTypeLambda')

UNDECLARED_VARIANT = Name(value='undeclaredVariant')

UNDEFINED_TERM_VARIABLE = Name(value='undefinedTermVariable')

UNDEFINED_TYPE_VARIABLE_IN_BINDING_TYPE = Name(value='undefinedTypeVariableInBindingType')

UNDEFINED_TYPE_VARIABLE_IN_LAMBDA_DOMAIN = Name(value='undefinedTypeVariableInLambdaDomain')

UNDEFINED_TYPE_VARIABLE_IN_TYPE_APPLICATION = Name(value='undefinedTypeVariableInTypeApplication')

UNKNOWN_CASE_ALTERNATIVE = Name(value='unknownCaseAlternative')

UNKNOWN_PRIMITIVE_NAME = Name(value='unknownPrimitiveName')

UNKNOWN_PROJECTED_FIELD = Name(value='unknownProjectedField')

UNNECESSARY_IDENTITY_APPLICATION = Name(value='unnecessaryIdentityApplication')

UNRESOLVED_NOMINAL_TYPE = Name(value='unresolvedNominalType')

UNTYPED_TERM_VARIABLE = Name(value='untypedTermVariable')

class hydra.error.core.InvalidTermErrorConstantCondition(value: T)

Bases: Node[ConstantConditionError]

An ifElse with a literal boolean condition (optional)

class hydra.error.core.InvalidTermErrorDuplicateBinding(value: T)

Bases: Node[DuplicateBindingError]

A duplicate binding name in a let expression

class hydra.error.core.InvalidTermErrorDuplicateField(value: T)

Bases: Node[DuplicateFieldError]

A duplicate field name in a record or case statement

class hydra.error.core.InvalidTermErrorEmptyCaseStatement(value: T)

Bases: Node[EmptyCaseStatementError]

A case statement with no cases and no default (optional)

class hydra.error.core.InvalidTermErrorEmptyLetBindings(value: T)

Bases: Node[EmptyLetBindingsError]

A let expression with no bindings (optional)

class hydra.error.core.InvalidTermErrorEmptyTermAnnotation(value: T)

Bases: Node[EmptyTermAnnotationError]

A term annotation with an empty annotation map (optional)

class hydra.error.core.InvalidTermErrorEmptyTypeNameInTerm(value: T)

Bases: Node[EmptyTypeNameInTermError]

A term with an empty type name (optional)

class hydra.error.core.InvalidTermErrorExtraRecordFields(value: T)

Bases: Node[ExtraRecordFieldsError]

A record term supplying a field not declared by its record type

class hydra.error.core.InvalidTermErrorInvalidLambdaParameterName(value: T)

Bases: Node[InvalidLambdaParameterNameError]

A lambda parameter name violating naming conventions (optional)

class hydra.error.core.InvalidTermErrorInvalidLetBindingName(value: T)

Bases: Node[InvalidLetBindingNameError]

A let binding name violating naming conventions (optional)

class hydra.error.core.InvalidTermErrorInvalidTypeLambdaParameterName(value: T)

Bases: Node[InvalidTypeLambdaParameterNameError]

A type lambda parameter name violating naming conventions (optional)

class hydra.error.core.InvalidTermErrorMissingCaseBranches(value: T)

Bases: Node[MissingCaseBranchesError]

A case statement that does not cover every variant of the union it matches

class hydra.error.core.InvalidTermErrorMissingRecordFields(value: T)

Bases: Node[MissingRecordFieldsError]

A record term omitting a field declared by its record type

class hydra.error.core.InvalidTermErrorNestedTermAnnotation(value: T)

Bases: Node[NestedTermAnnotationError]

Nested term annotations that should be merged (optional)

class hydra.error.core.InvalidTermErrorNominalTypeKindMismatch(value: T)

Bases: Node[NominalTypeKindMismatchError]

A nominal type reference resolving to a type of the wrong kind (e.g. a record term naming a union type)

class hydra.error.core.InvalidTermErrorRedundantWrapUnwrap(value: T)

Bases: Node[RedundantWrapUnwrapError]

A no-op unwrap-of-wrap round-trip (optional)

class hydra.error.core.InvalidTermErrorSelfApplication(value: T)

Bases: Node[SelfApplicationError]

A variable applied to itself (optional)

class hydra.error.core.InvalidTermErrorTermVariableShadowing(value: T)

Bases: Node[TermVariableShadowingError]

A binding that shadows a variable already in scope (optional)

class hydra.error.core.InvalidTermErrorTypeVariableShadowingInTypeLambda(value: T)

Bases: Node[TypeVariableShadowingInTypeLambdaError]

A type lambda parameter that shadows a type variable in scope (optional)

class hydra.error.core.InvalidTermErrorUndeclaredVariant(value: T)

Bases: Node[UndeclaredVariantError]

An injection naming a variant that is not declared by its union type

class hydra.error.core.InvalidTermErrorUndefinedTermVariable(value: T)

Bases: Node[UndefinedTermVariableError]

A variable reference to an unbound term name

class hydra.error.core.InvalidTermErrorUndefinedTypeVariableInBindingType(value: T)

Bases: Node[UndefinedTypeVariableInBindingTypeError]

An unbound type variable in a let binding’s type scheme

class hydra.error.core.InvalidTermErrorUndefinedTypeVariableInLambdaDomain(value: T)

Bases: Node[UndefinedTypeVariableInLambdaDomainError]

An unbound type variable in a lambda domain annotation

class hydra.error.core.InvalidTermErrorUndefinedTypeVariableInTypeApplication(value: T)

Bases: Node[UndefinedTypeVariableInTypeApplicationError]

An unbound type variable in a type application term

class hydra.error.core.InvalidTermErrorUnknownCaseAlternative(value: T)

Bases: Node[UnknownCaseAlternativeError]

A case statement alternative naming a field that does not exist in the union it matches

class hydra.error.core.InvalidTermErrorUnknownPrimitiveName(value: T)

Bases: Node[UnknownPrimitiveNameError]

A reference to an unknown primitive function

class hydra.error.core.InvalidTermErrorUnknownProjectedField(value: T)

Bases: Node[UnknownProjectedFieldError]

A projection naming a field that is not declared by its record type

class hydra.error.core.InvalidTermErrorUnnecessaryIdentityApplication(value: T)

Bases: Node[UnnecessaryIdentityApplicationError]

An identity lambda applied to an argument (optional)

class hydra.error.core.InvalidTermErrorUnresolvedNominalType(value: T)

Bases: Node[UnresolvedNominalTypeError]

A nominal type reference that does not resolve to any declared type in scope

class hydra.error.core.InvalidTermErrorUntypedTermVariable(value: T)

Bases: Node[UntypedTermVariableError]

A term variable whose type is not known

class hydra.error.core.InvalidTypeError

Bases: object

InvalidTypeErrorDuplicateRecordTypeFieldNames | InvalidTypeErrorDuplicateUnionTypeFieldNames | InvalidTypeErrorEmptyRecordType | InvalidTypeErrorEmptyTypeAnnotation | InvalidTypeErrorEmptyUnionType | InvalidTypeErrorInvalidForallParameterName | InvalidTypeErrorInvalidTypeSchemeVariableName | InvalidTypeErrorNestedTypeAnnotation | InvalidTypeErrorNonComparableMapKeyType | InvalidTypeErrorNonComparableSetElementType | InvalidTypeErrorSingleVariantUnion | InvalidTypeErrorTypeVariableShadowingInForall | InvalidTypeErrorUndefinedTypeVariable | InvalidTypeErrorVoidInNonBottomPosition

DUPLICATE_RECORD_TYPE_FIELD_NAMES = Name(value='duplicateRecordTypeFieldNames')

DUPLICATE_UNION_TYPE_FIELD_NAMES = Name(value='duplicateUnionTypeFieldNames')

EMPTY_RECORD_TYPE = Name(value='emptyRecordType')

EMPTY_TYPE_ANNOTATION = Name(value='emptyTypeAnnotation')

EMPTY_UNION_TYPE = Name(value='emptyUnionType')

INVALID_FORALL_PARAMETER_NAME = Name(value='invalidForallParameterName')

INVALID_TYPE_SCHEME_VARIABLE_NAME = Name(value='invalidTypeSchemeVariableName')

NESTED_TYPE_ANNOTATION = Name(value='nestedTypeAnnotation')

NON_COMPARABLE_MAP_KEY_TYPE = Name(value='nonComparableMapKeyType')

NON_COMPARABLE_SET_ELEMENT_TYPE = Name(value='nonComparableSetElementType')

SINGLE_VARIANT_UNION = Name(value='singleVariantUnion')

TYPE_ = Name(value='hydra.error.core.InvalidTypeError')

TYPE_VARIABLE_SHADOWING_IN_FORALL = Name(value='typeVariableShadowingInForall')

UNDEFINED_TYPE_VARIABLE = Name(value='undefinedTypeVariable')

VOID_IN_NON_BOTTOM_POSITION = Name(value='voidInNonBottomPosition')

class hydra.error.core.InvalidTypeErrorDuplicateRecordTypeFieldNames(value: T)

Bases: Node[DuplicateRecordTypeFieldNamesError]

A record type with duplicate field names

class hydra.error.core.InvalidTypeErrorDuplicateUnionTypeFieldNames(value: T)

Bases: Node[DuplicateUnionTypeFieldNamesError]

A union type with duplicate field names

class hydra.error.core.InvalidTypeErrorEmptyRecordType(value: T)

Bases: Node[EmptyRecordTypeError]

A record type with no fields (optional)

class hydra.error.core.InvalidTypeErrorEmptyTypeAnnotation(value: T)

Bases: Node[EmptyTypeAnnotationError]

A type annotation with an empty annotation map (optional)

class hydra.error.core.InvalidTypeErrorEmptyUnionType(value: T)

Bases: Node[EmptyUnionTypeError]

A union type with no alternatives (optional)

class hydra.error.core.InvalidTypeErrorInvalidForallParameterName(value: T)

Bases: Node[InvalidForallParameterNameError]

A forall parameter name violating naming conventions (optional)

class hydra.error.core.InvalidTypeErrorInvalidTypeSchemeVariableName(value: T)

Bases: Node[InvalidTypeSchemeVariableNameError]

A type scheme variable name violating naming conventions (optional)

class hydra.error.core.InvalidTypeErrorNestedTypeAnnotation(value: T)

Bases: Node[NestedTypeAnnotationError]

Nested type annotations that should be merged (optional)

class hydra.error.core.InvalidTypeErrorNonComparableMapKeyType(value: T)

Bases: Node[NonComparableMapKeyTypeError]

A map with a non-comparable key type

class hydra.error.core.InvalidTypeErrorNonComparableSetElementType(value: T)

Bases: Node[NonComparableSetElementTypeError]

A set with a non-comparable element type

class hydra.error.core.InvalidTypeErrorSingleVariantUnion(value: T)

Bases: Node[SingleVariantUnionError]

A union type with only one variant (optional)

class hydra.error.core.InvalidTypeErrorTypeVariableShadowingInForall(value: T)

Bases: Node[TypeVariableShadowingInForallError]

A forall parameter that shadows a type variable in scope (optional)

class hydra.error.core.InvalidTypeErrorUndefinedTypeVariable(value: T)

Bases: Node[UndefinedTypeVariableError]

A type variable reference to an unbound name

class hydra.error.core.InvalidTypeErrorVoidInNonBottomPosition(value: T)

Bases: Node[VoidInNonBottomPositionError]

TypeVoid in a position where no value can be constructed (optional)

class hydra.error.core.InvalidTypeLambdaParameterNameError(location: Annotated[SubtermPath, 'The path to the type lambda within the term'], name: Annotated[Name, 'The invalid type lambda parameter name'])

Bases: object

A type lambda parameter name that violates naming conventions (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.InvalidTypeLambdaParameterNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the type lambda within the term']

name: Annotated[Name, 'The invalid type lambda parameter name']

with_location(location)

with_name(name)

class hydra.error.core.InvalidTypeSchemeVariableNameError(location: Annotated[SubtermPath, 'The path to the type scheme'], name: Annotated[Name, 'The invalid variable name'])

Bases: object

A type scheme variable name that violates type variable naming conventions (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.InvalidTypeSchemeVariableNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the type scheme']

name: Annotated[Name, 'The invalid variable name']

with_location(location)

with_name(name)

class hydra.error.core.LiteralTypeMismatchError(expected_type: Annotated[LiteralType, 'The expected literal type'], actual_type: Annotated[LiteralType, 'The actual literal type, derived from the value'])

Bases: object

A mismatch between an expected literal type and the type of an actual literal value.

ACTUAL_TYPE = Name(value='actualType')

class Builder(_expected_type: 'hydra.core.LiteralType' = None, _actual_type: 'hydra.core.LiteralType' = None)

Bases: object

actual_type(actual_type)

build()

expected_type(expected_type)

EXPECTED_TYPE = Name(value='expectedType')

TYPE_ = Name(value='hydra.error.core.LiteralTypeMismatchError')

actual_type: Annotated[LiteralType, 'The actual literal type, derived from the value']

static builder()

expected_type: Annotated[LiteralType, 'The expected literal type']

with_actual_type(actual_type)

with_expected_type(expected_type)

class hydra.error.core.MissingCaseBranchesError(location: Annotated[SubtermPath, 'The path to the case statement within the term'], type_name: Annotated[Name, 'The name of the union type being matched'], variant_names: Annotated[Sequence[Name], 'The names of the uncovered variants'])

Bases: object

A case statement without a default branch that fails to cover every variant of the union it matches.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _variant_names: 'Sequence[hydra.core.Name]' = None)

Bases: object

build()

location(location)

type_name(type_name)

variant_names(variant_names)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.MissingCaseBranchesError')

TYPE_NAME = Name(value='typeName')

VARIANT_NAMES = Name(value='variantNames')

static builder()

location: Annotated[SubtermPath, 'The path to the case statement within the term']

type_name: Annotated[Name, 'The name of the union type being matched']

variant_names: Annotated[Sequence[Name], 'The names of the uncovered variants']

with_location(location)

with_type_name(type_name)

with_variant_names(variant_names)

class hydra.error.core.MissingRecordFieldsError(location: Annotated[SubtermPath, 'The path to the record term within the term'], type_name: Annotated[Name, 'The name of the record type'], field_names: Annotated[Sequence[Name], 'The names of the missing fields'])

Bases: object

A record term omitting a field declared by its record type.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _field_names: 'Sequence[hydra.core.Name]' = None)

Bases: object

build()

field_names(field_names)

location(location)

type_name(type_name)

FIELD_NAMES = Name(value='fieldNames')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.MissingRecordFieldsError')

TYPE_NAME = Name(value='typeName')

static builder()

field_names: Annotated[Sequence[Name], 'The names of the missing fields']

location: Annotated[SubtermPath, 'The path to the record term within the term']

type_name: Annotated[Name, 'The name of the record type']

with_field_names(field_names)

with_location(location)

with_type_name(type_name)

class hydra.error.core.NestedTermAnnotationError(location: Annotated[SubtermPath, 'The path to the outer annotation within the term'])

Bases: object

A term annotation directly wrapping another term annotation; annotations should be merged (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.NestedTermAnnotationError')

static builder()

location: Annotated[SubtermPath, 'The path to the outer annotation within the term']

with_location(location)

class hydra.error.core.NestedTypeAnnotationError(location: Annotated[SubtermPath, 'The path to the outer annotation'])

Bases: object

A type annotation directly wrapping another type annotation; annotations should be merged (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.NestedTypeAnnotationError')

static builder()

location: Annotated[SubtermPath, 'The path to the outer annotation']

with_location(location)

class hydra.error.core.NominalTypeKindMismatchError(location: Annotated[SubtermPath, 'The path to the term with the mismatched nominal type reference'], type_name: Annotated[Name, 'The name of the referenced type'], expected_variant: Annotated[TypeVariant, 'The type variant required at this site'], actual_variant: Annotated[TypeVariant, 'The type variant that the name actually resolves to'])

Bases: object

A nominal type reference in a term (inject, cases, record, project, wrap, or unwrap) resolving to a declared type of the wrong kind, e.g. a record term naming a union type.

ACTUAL_VARIANT = Name(value='actualVariant')

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _expected_variant: 'hydra.variants.TypeVariant' = None, _actual_variant: 'hydra.variants.TypeVariant' = None)

Bases: object

actual_variant(actual_variant)

build()

expected_variant(expected_variant)

location(location)

type_name(type_name)

EXPECTED_VARIANT = Name(value='expectedVariant')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.NominalTypeKindMismatchError')

TYPE_NAME = Name(value='typeName')

actual_variant: Annotated[TypeVariant, 'The type variant that the name actually resolves to']

static builder()

expected_variant: Annotated[TypeVariant, 'The type variant required at this site']

location: Annotated[SubtermPath, 'The path to the term with the mismatched nominal type reference']

type_name: Annotated[Name, 'The name of the referenced type']

with_actual_variant(actual_variant)

with_expected_variant(expected_variant)

with_location(location)

with_type_name(type_name)

class hydra.error.core.NonComparableMapKeyTypeError(location: Annotated[SubtermPath, 'The path to the map type'], key_type: Annotated[Type, 'The non-comparable key type'])

Bases: object

A map type whose key type is or directly contains a function type, which cannot be compared for equality.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _key_type: 'hydra.core.Type' = None)

Bases: object

build()

key_type(key_type)

location(location)

KEY_TYPE = Name(value='keyType')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.NonComparableMapKeyTypeError')

static builder()

key_type: Annotated[Type, 'The non-comparable key type']

location: Annotated[SubtermPath, 'The path to the map type']

with_key_type(key_type)

with_location(location)

class hydra.error.core.NonComparableSetElementTypeError(location: Annotated[SubtermPath, 'The path to the set type'], element_type: Annotated[Type, 'The non-comparable element type'])

Bases: object

A set type whose element type is or directly contains a function type, which cannot be compared for equality.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _element_type: 'hydra.core.Type' = None)

Bases: object

build()

element_type(element_type)

location(location)

ELEMENT_TYPE = Name(value='elementType')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.NonComparableSetElementTypeError')

static builder()

element_type: Annotated[Type, 'The non-comparable element type']

location: Annotated[SubtermPath, 'The path to the set type']

with_element_type(element_type)

with_location(location)

class hydra.error.core.RedundantWrapUnwrapError(location: Annotated[SubtermPath, 'The path to the redundant wrap/unwrap within the term'], type_name: Annotated[Name, 'The type name of the wrapper'])

Bases: object

An unwrap elimination applied to a wrap term of the same type, forming a no-op round-trip (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

type_name(type_name)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.RedundantWrapUnwrapError')

TYPE_NAME = Name(value='typeName')

static builder()

location: Annotated[SubtermPath, 'The path to the redundant wrap/unwrap within the term']

type_name: Annotated[Name, 'The type name of the wrapper']

with_location(location)

with_type_name(type_name)

class hydra.error.core.SelfApplicationError(location: Annotated[SubtermPath, 'The path to the self-application within the term'], name: Annotated[Name, 'The name of the variable applied to itself'])

Bases: object

A variable applied to itself, which is almost always a mistake in Hydra’s type system (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.SelfApplicationError')

static builder()

location: Annotated[SubtermPath, 'The path to the self-application within the term']

name: Annotated[Name, 'The name of the variable applied to itself']

with_location(location)

with_name(name)

class hydra.error.core.SingleVariantUnionError(location: Annotated[SubtermPath, 'The path to the single-variant union type'], field_name: Annotated[Name, 'The name of the single field'])

Bases: object

A union type with exactly one field; could be a wrapped type or record instead (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _field_name: 'hydra.core.Name' = None)

Bases: object

build()

field_name(field_name)

location(location)

FIELD_NAME = Name(value='fieldName')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.SingleVariantUnionError')

static builder()

field_name: Annotated[Name, 'The name of the single field']

location: Annotated[SubtermPath, 'The path to the single-variant union type']

with_field_name(field_name)

with_location(location)

class hydra.error.core.TermVariableShadowingError(location: Annotated[SubtermPath, 'The path to the shadowing binding within the term'], name: Annotated[Name, 'The name of the shadowed variable'])

Bases: object

A lambda parameter or let binding name that shadows a variable already in scope (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.TermVariableShadowingError')

static builder()

location: Annotated[SubtermPath, 'The path to the shadowing binding within the term']

name: Annotated[Name, 'The name of the shadowed variable']

with_location(location)

with_name(name)

class hydra.error.core.TypeVariableShadowingInForallError(location: Annotated[SubtermPath, 'The path to the shadowing forall type'], name: Annotated[Name, 'The name of the shadowed type variable'])

Bases: object

A forall type parameter that shadows a type variable already in scope (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.TypeVariableShadowingInForallError')

static builder()

location: Annotated[SubtermPath, 'The path to the shadowing forall type']

name: Annotated[Name, 'The name of the shadowed type variable']

with_location(location)

with_name(name)

class hydra.error.core.TypeVariableShadowingInTypeLambdaError(location: Annotated[SubtermPath, 'The path to the type lambda within the term'], name: Annotated[Name, 'The name of the shadowed type variable'])

Bases: object

A type lambda parameter that shadows a type variable already in scope (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.TypeVariableShadowingInTypeLambdaError')

static builder()

location: Annotated[SubtermPath, 'The path to the type lambda within the term']

name: Annotated[Name, 'The name of the shadowed type variable']

with_location(location)

with_name(name)

class hydra.error.core.UndeclaredVariantError(location: Annotated[SubtermPath, 'The path to the injection within the term'], type_name: Annotated[Name, 'The name of the union type'], variant_name: Annotated[Name, 'The undeclared variant name'])

Bases: object

An injection naming a variant that is not declared by its union type.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _variant_name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

type_name(type_name)

variant_name(variant_name)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.UndeclaredVariantError')

TYPE_NAME = Name(value='typeName')

VARIANT_NAME = Name(value='variantName')

static builder()

location: Annotated[SubtermPath, 'The path to the injection within the term']

type_name: Annotated[Name, 'The name of the union type']

variant_name: Annotated[Name, 'The undeclared variant name']

with_location(location)

with_type_name(type_name)

with_variant_name(variant_name)

class hydra.error.core.UndefinedFieldError(field_name: Annotated[Name, 'The name of the undefined field'], type_name: Annotated[Name, 'The name of the type in which the field was expected'])

Bases: object

A reference to a field that does not exist in the given type.

class Builder(_field_name: 'hydra.core.Name' = None, _type_name: 'hydra.core.Name' = None)

Bases: object

build()

field_name(field_name)

type_name(type_name)

FIELD_NAME = Name(value='fieldName')

TYPE_ = Name(value='hydra.error.core.UndefinedFieldError')

TYPE_NAME = Name(value='typeName')

static builder()

field_name: Annotated[Name, 'The name of the undefined field']

type_name: Annotated[Name, 'The name of the type in which the field was expected']

with_field_name(field_name)

with_type_name(type_name)

class hydra.error.core.UndefinedTermVariableError(location: Annotated[SubtermPath, 'The path to the undefined variable within the term'], name: Annotated[Name, 'The name of the undefined variable'])

Bases: object

A variable reference to a term name that is not bound in scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UndefinedTermVariableError')

static builder()

location: Annotated[SubtermPath, 'The path to the undefined variable within the term']

name: Annotated[Name, 'The name of the undefined variable']

with_location(location)

with_name(name)

class hydra.error.core.UndefinedTypeVariableError(location: Annotated[SubtermPath, 'The path to the undefined type variable'], name: Annotated[Name, 'The name of the undefined type variable'])

Bases: object

A type variable reference to a name that is not bound in scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UndefinedTypeVariableError')

static builder()

location: Annotated[SubtermPath, 'The path to the undefined type variable']

name: Annotated[Name, 'The name of the undefined type variable']

with_location(location)

with_name(name)

class hydra.error.core.UndefinedTypeVariableInBindingTypeError(location: Annotated[SubtermPath, 'The path to the binding within the term'], name: Annotated[Name, 'The name of the undefined type variable'])

Bases: object

A type variable in a let binding’s type scheme that is not bound by the scheme or enclosing scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UndefinedTypeVariableInBindingTypeError')

static builder()

location: Annotated[SubtermPath, 'The path to the binding within the term']

name: Annotated[Name, 'The name of the undefined type variable']

with_location(location)

with_name(name)

class hydra.error.core.UndefinedTypeVariableInLambdaDomainError(location: Annotated[SubtermPath, 'The path to the lambda within the term'], name: Annotated[Name, 'The name of the undefined type variable'])

Bases: object

A type variable in a lambda domain annotation that is not bound in scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UndefinedTypeVariableInLambdaDomainError')

static builder()

location: Annotated[SubtermPath, 'The path to the lambda within the term']

name: Annotated[Name, 'The name of the undefined type variable']

with_location(location)

with_name(name)

class hydra.error.core.UndefinedTypeVariableInTypeApplicationError(location: Annotated[SubtermPath, 'The path to the type application within the term'], name: Annotated[Name, 'The name of the undefined type variable'])

Bases: object

A type variable in a type application term that is not bound in scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UndefinedTypeVariableInTypeApplicationError')

static builder()

location: Annotated[SubtermPath, 'The path to the type application within the term']

name: Annotated[Name, 'The name of the undefined type variable']

with_location(location)

with_name(name)

class hydra.error.core.UnexpectedTermVariantError(expected_variant: Annotated[TermVariant, 'The expected term variant'], actual_term: Annotated[Term, 'The actual term that was encountered'])

Bases: object

An unexpected term variant was encountered.

ACTUAL_TERM = Name(value='actualTerm')

class Builder(_expected_variant: 'hydra.variants.TermVariant' = None, _actual_term: 'hydra.core.Term' = None)

Bases: object

actual_term(actual_term)

build()

expected_variant(expected_variant)

EXPECTED_VARIANT = Name(value='expectedVariant')

TYPE_ = Name(value='hydra.error.core.UnexpectedTermVariantError')

actual_term: Annotated[Term, 'The actual term that was encountered']

static builder()

expected_variant: Annotated[TermVariant, 'The expected term variant']

with_actual_term(actual_term)

with_expected_variant(expected_variant)

class hydra.error.core.UnexpectedTypeVariantError(expected_variant: Annotated[TypeVariant, 'The expected type variant'], actual_type: Annotated[Type, 'The actual type that was encountered'])

Bases: object

An unexpected type variant was encountered.

ACTUAL_TYPE = Name(value='actualType')

class Builder(_expected_variant: 'hydra.variants.TypeVariant' = None, _actual_type: 'hydra.core.Type' = None)

Bases: object

actual_type(actual_type)

build()

expected_variant(expected_variant)

EXPECTED_VARIANT = Name(value='expectedVariant')

TYPE_ = Name(value='hydra.error.core.UnexpectedTypeVariantError')

actual_type: Annotated[Type, 'The actual type that was encountered']

static builder()

expected_variant: Annotated[TypeVariant, 'The expected type variant']

with_actual_type(actual_type)

with_expected_variant(expected_variant)

class hydra.error.core.UnknownCaseAlternativeError(location: Annotated[SubtermPath, 'The path to the case statement within the term'], type_name: Annotated[Name, 'The name of the union type being matched'], name: Annotated[Name, 'The unknown alternative name'])

Bases: object

A case statement alternative naming a field that does not exist in the union it matches.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

type_name(type_name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UnknownCaseAlternativeError')

TYPE_NAME = Name(value='typeName')

static builder()

location: Annotated[SubtermPath, 'The path to the case statement within the term']

name: Annotated[Name, 'The unknown alternative name']

type_name: Annotated[Name, 'The name of the union type being matched']

with_location(location)

with_name(name)

with_type_name(type_name)

class hydra.error.core.UnknownPrimitiveNameError(location: Annotated[SubtermPath, 'The path to the primitive reference within the term'], name: Annotated[Name, 'The unknown primitive name'])

Bases: object

A primitive function reference to a name not in the known primitive registry.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UnknownPrimitiveNameError')

static builder()

location: Annotated[SubtermPath, 'The path to the primitive reference within the term']

name: Annotated[Name, 'The unknown primitive name']

with_location(location)

with_name(name)

class hydra.error.core.UnknownProjectedFieldError(location: Annotated[SubtermPath, 'The path to the projection within the term'], type_name: Annotated[Name, 'The name of the record type'], field_name: Annotated[Name, 'The unknown projected field name'])

Bases: object

A projection naming a field that is not declared by its record type.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None, _field_name: 'hydra.core.Name' = None)

Bases: object

build()

field_name(field_name)

location(location)

type_name(type_name)

FIELD_NAME = Name(value='fieldName')

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.UnknownProjectedFieldError')

TYPE_NAME = Name(value='typeName')

static builder()

field_name: Annotated[Name, 'The unknown projected field name']

location: Annotated[SubtermPath, 'The path to the projection within the term']

type_name: Annotated[Name, 'The name of the record type']

with_field_name(field_name)

with_location(location)

with_type_name(type_name)

class hydra.error.core.UnnecessaryIdentityApplicationError(location: Annotated[SubtermPath, 'The path to the identity application within the term'])

Bases: object

An application of an identity lambda to an argument, which simplifies to the argument (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.UnnecessaryIdentityApplicationError')

static builder()

location: Annotated[SubtermPath, 'The path to the identity application within the term']

with_location(location)

class hydra.error.core.UnresolvedNominalTypeError(location: Annotated[SubtermPath, 'The path to the term with the unresolved nominal type reference'], type_name: Annotated[Name, 'The unresolved type name'])

Bases: object

A nominal type reference in a term (inject, cases, record, project, wrap, or unwrap) that does not resolve to any declared type in scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _type_name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

type_name(type_name)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.UnresolvedNominalTypeError')

TYPE_NAME = Name(value='typeName')

static builder()

location: Annotated[SubtermPath, 'The path to the term with the unresolved nominal type reference']

type_name: Annotated[Name, 'The unresolved type name']

with_location(location)

with_type_name(type_name)

class hydra.error.core.UntypedTermVariableError(location: Annotated[SubtermPath, 'The path to the untyped variable within the term'], name: Annotated[Name, 'The name of the untyped variable'])

Bases: object

A term variable whose type is not known in the current scope.

class Builder(_location: 'hydra.paths.SubtermPath' = None, _name: 'hydra.core.Name' = None)

Bases: object

build()

location(location)

name(name)

LOCATION = Name(value='location')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.error.core.UntypedTermVariableError')

static builder()

location: Annotated[SubtermPath, 'The path to the untyped variable within the term']

name: Annotated[Name, 'The name of the untyped variable']

with_location(location)

with_name(name)

class hydra.error.core.VoidInNonBottomPositionError(location: Annotated[SubtermPath, 'The path to the void type in a non-bottom position'])

Bases: object

TypeVoid appearing in a position where no value can be constructed, such as a record field, list element, map key/value, set element, pair component, or function codomain (optional).

class Builder(_location: 'hydra.paths.SubtermPath' = None)

Bases: object

build()

location(location)

LOCATION = Name(value='location')

TYPE_ = Name(value='hydra.error.core.VoidInNonBottomPositionError')

static builder()

location: Annotated[SubtermPath, 'The path to the void type in a non-bottom position']

with_location(location)