Enum TypeError 

#[non_exhaustive]
pub enum TypeError {
    Mismatch {
        expected: Type,
        found: Type,
    },
    Occurs {
        var: TyVar,
        ty: Type,
    },
}

The reason a unify call failed.

Unification fails in exactly two ways, each a distinct, defined outcome rather than a panic:

• the two types are built from different constructors, or the same constructor applied to a different number of arguments (Mismatch), or
• binding a variable would make it refer to itself, producing an infinite type (Occurs).

Both variants carry the offending types, fully resolved under the substitution at the point of failure, so the failure is actionable when it is rendered far from the call that produced it — typically by mapping it onto a diag-lang diagnostic with the consumer’s own type names.

The enum is #[non_exhaustive]: a downstream match must include a wildcard arm, so a later addition is a minor change, not a breaking one.

Examples

use type_lang::{TyCon, Type, TypeError, Unifier};

const INT: TyCon = TyCon::new(0);
const BOOL: TyCon = TyCon::new(1);

let mut unifier = Unifier::new();
let err = unifier
    .unify(&Type::con(INT), &Type::con(BOOL))
    .unwrap_err();
assert!(matches!(err, TypeError::Mismatch { .. }));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Mismatch

The two types do not share a constructor.

Returned when the heads differ (Int versus Bool) or when the same head is applied to a different arity (Pair<A> versus Pair<A, B>). Both sides are resolved under the current substitution before being stored, so they show the most concrete form known at the point of failure.

unify(a, b) records a as expected and b as found. Unification itself is symmetric — the labels only reflect the argument order, to match the common “expected this, found that” phrasing of a type error.

Fields

expected: Type

The first type given to unify, resolved.

found: Type

The second type given to unify, resolved.

Occurs

Binding a variable would make it occur within its own definition.

Returned when a variable would be bound to a type that already contains it — for example unifying ?0 with List<?0>. Such a binding describes an infinitely deep type, which the occurs check rejects so that resolution always terminates.

Fields

var: TyVar

The variable that would refer to itself.

ty: Type

The type it would have been bound to, resolved.

Trait Implementations

impl Clone for TypeError

fn clone(&self) -> TypeError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for TypeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for TypeError

impl Error for TypeError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for TypeError

fn eq(&self, other: &TypeError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TypeError