pub enum Error<'a> {
Show 76 variants
DuplicateTest {
name: &'a str,
first: Region,
second: Region,
},
ValidatorMissingMain {
region: Region,
module: &'a str,
},
ValidatorMainNotExposed {
region: Region,
module: &'a str,
},
RecordLiteralNoAlias {
region: Region,
fields: &'a [&'a str],
},
RecordLiteralAmbiguous {
region: Region,
candidates: &'a [QualifiedName<'a>],
},
RecordTypeOutsideAlias {
region: Region,
},
OutOfFuel {
region: Region,
},
NegateWithoutNum {
region: Region,
},
DoWithoutMonad {
region: Region,
},
RefutableBindPattern {
region: Region,
},
StructuralEqOverride {
head: &'a Located<Type<'a>>,
},
ReflexiveLiftOverlap {
heads: &'a [&'a Located<Type<'a>>],
},
MissingSuperclass {
region: Region,
trait_: QualifiedName<'a>,
heads: &'a [Located<Head<'a>>],
superclass: &'a Pred<'a>,
index: u16,
reason: Failure,
},
BadInstanceHead {
region: Region,
reason: BadHead,
},
ImplContextVarNotInHead {
region: Region,
name: &'a str,
},
MissingMethod {
region: Region,
trait_: &'a str,
name: &'a str,
},
UnknownMethod {
region: Region,
trait_: &'a str,
name: &'a str,
},
OrphanImpl {
region: Region,
trait_: QualifiedName<'a>,
heads: &'a [HeadCon<'a>],
},
OverlappingImpls {
key: &'a ImplKey<'a>,
first: Region,
second: Region,
first_home: ModuleName<'a>,
second_home: ModuleName<'a>,
},
ImportOpenTrait {
region: Region,
name: &'a str,
},
DuplicateTrait {
name: &'a str,
first: Region,
second: Region,
},
DuplicateMethod {
name: &'a str,
first: Region,
second: Region,
},
DuplicateTraitParameter {
name: &'a str,
first: Region,
second: Region,
},
SuperclassBadArg {
region: Region,
trait_: &'a str,
},
MethodMissingParameter {
region: Region,
method: &'a str,
parameter: &'a str,
},
RecursiveSuperclass {
names: &'a [&'a Located<&'a str>],
},
ExportOpenTrait {
region: Region,
name: &'a str,
},
NotFoundTrait {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
},
AmbiguousTrait {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
TraitArity {
region: Region,
name: &'a str,
expected: usize,
actual: usize,
},
ContextVarNotInType {
region: Region,
name: &'a str,
},
KindMismatch {
region: Region,
context: &'a KindContext<'a>,
expected: &'a Kind<'a>,
actual: &'a Kind<'a>,
},
KindInfinite {
region: Region,
context: &'a KindContext<'a>,
},
RepresentationMismatch {
region: Region,
context: &'a KindContext<'a>,
required: ReprTrait,
actual: Repr,
},
ContradictoryRepresentation {
region: Region,
subject: &'a Located<Type<'a>>,
},
ImplOfBuiltinTrait {
region: Region,
trait_: QualifiedName<'a>,
},
IrregularRecursion {
region: Region,
constructor: QualifiedName<'a>,
parameter: &'a str,
},
Unsupported {
feature: &'static str,
region: Region,
},
MissingModuleHeader,
NotFoundType {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
ImportNotFound {
region: Region,
module: &'a str,
},
AmbiguousType {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
BadArity {
region: Region,
context: BadArityContext,
name: &'a str,
expected: usize,
actual: usize,
},
ExportNotFound {
region: Region,
kind: VarKind,
name: &'a str,
suggestions: &'a [&'a str],
},
ExportOpenAlias {
region: Region,
name: &'a str,
},
DuplicateDecl {
name: &'a str,
first: Region,
second: Region,
},
DuplicateType {
name: &'a str,
first: Region,
second: Region,
},
DuplicateCtor {
name: &'a str,
first: Region,
second: Region,
},
DuplicateBinop {
name: &'a str,
first: Region,
second: Region,
},
BinopFunctionNotFound {
region: Region,
op: &'a str,
function: &'a str,
},
DuplicateUnionArg {
type_name: &'a str,
arg_name: &'a str,
first: Region,
second: Region,
},
DuplicateAliasArg {
type_name: &'a str,
arg_name: &'a str,
first: Region,
second: Region,
},
RecursiveAlias {
region: Region,
name: &'a str,
args: &'a [&'a str],
typ: &'a Located<Type<'a>>,
others: &'a [&'a str],
},
TypeVarsUnboundInUnion {
region: Region,
name: &'a str,
args: &'a [&'a str],
unbound: (&'a str, Region),
more_unbound: &'a [(&'a str, Region)],
},
TypeVarsMessedUpInAlias {
region: Region,
name: &'a str,
args: &'a [&'a str],
unused: &'a [(&'a str, Region)],
unbound: &'a [(&'a str, Region)],
},
LabeledCtorMissingField {
region: Region,
ctor: &'a str,
field: &'a str,
},
LabeledCtorExtraField {
region: Region,
ctor: &'a str,
field: &'a str,
},
LabeledCtorUnknownField {
region: Region,
ctor: &'a str,
field: &'a str,
},
DuplicateField {
name: &'a str,
first: Region,
second: Region,
},
ExportDuplicate {
name: &'a str,
first: Region,
second: Region,
},
NotFoundCtor {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
AmbiguousCtor {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
PatternHasRecordCtor {
region: Region,
name: &'a str,
},
DuplicatePattern {
context: DuplicatePatternContext<'a>,
name: &'a str,
first: Region,
second: Region,
},
NotFoundVar {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
AmbiguousVar {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
NotFoundBinop {
region: Region,
name: &'a str,
available: &'a [&'a str],
},
AmbiguousBinop {
region: Region,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
BinopConflict {
region: Region,
op1: &'a str,
op2: &'a str,
},
Shadowing {
name: &'a str,
original: Region,
new: Region,
},
RecursiveLet {
name: &'a Located<&'a str>,
others: &'a [&'a str],
},
RecursiveDecl {
name: &'a Located<&'a str>,
others: &'a [&'a str],
},
AnnotationTooShort {
region: Region,
name: &'a str,
index: usize,
leftovers: usize,
},
ImportExposingNotFound {
region: Region,
module: ModuleName<'a>,
name: &'a str,
available: &'a [&'a str],
},
ImportCtorByName {
region: Region,
name: &'a str,
type_name: &'a str,
},
ImportOpenAlias {
region: Region,
name: &'a str,
},
}Variants§
DuplicateTest
ValidatorMissingMain
ValidatorMainNotExposed
RecordLiteralNoAlias
RecordLiteralAmbiguous
RecordTypeOutsideAlias
OutOfFuel
Overlap or superclass search used up the compile’s fuel.
NegateWithoutNum
DoWithoutMonad
RefutableBindPattern
StructuralEqOverride
ReflexiveLiftOverlap
MissingSuperclass
Fields
§
trait_: QualifiedName<'a>BadInstanceHead
ImplContextVarNotInHead
MissingMethod
UnknownMethod
OrphanImpl
OverlappingImpls
ImportOpenTrait
DuplicateTrait
DuplicateMethod
DuplicateTraitParameter
SuperclassBadArg
MethodMissingParameter
RecursiveSuperclass
ExportOpenTrait
NotFoundTrait
AmbiguousTrait
TraitArity
ContextVarNotInType
KindMismatch
KindInfinite
RepresentationMismatch
ContradictoryRepresentation
Fields
ImplOfBuiltinTrait
IrregularRecursion
Unsupported
MissingModuleHeader
NotFoundType
ImportNotFound
AmbiguousType
BadArity
ExportNotFound
Fields
ExportOpenAlias
DuplicateDecl
DuplicateType
DuplicateCtor
DuplicateBinop
BinopFunctionNotFound
An infix declaration’s function is not a top-level value of the
module. Elm never validates this (infix is kernel-only there, and
its interface extraction crashes on the missing annotation); Nash
allows user-defined operators, so it must be a real error.
DuplicateUnionArg
DuplicateAliasArg
RecursiveAlias
Fields
TypeVarsUnboundInUnion
Fields
TypeVarsMessedUpInAlias
Fields
LabeledCtorMissingField
LabeledCtorExtraField
LabeledCtorUnknownField
DuplicateField
ExportDuplicate
NotFoundCtor
AmbiguousCtor
PatternHasRecordCtor
DuplicatePattern
NotFoundVar
AmbiguousVar
NotFoundBinop
AmbiguousBinop
BinopConflict
Shadowing
RecursiveLet
RecursiveDecl
AnnotationTooShort
Fields
ImportExposingNotFound
ImportCtorByName
ImportOpenAlias
Trait Implementations§
Auto Trait Implementations§
impl<'a> Freeze for Error<'a>
impl<'a> RefUnwindSafe for Error<'a>
impl<'a> Send for Error<'a>
impl<'a> Sync for Error<'a>
impl<'a> Unpin for Error<'a>
impl<'a> UnsafeUnpin for Error<'a>
impl<'a> UnwindSafe for Error<'a>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more