Trait rustc::ty::relate::Relate

pub trait Relate<'tcx>: TypeFoldable<'tcx> {
    fn relate<'a, 'gcx, R>(
        relation: &mut R, 
        a: &Self, 
        b: &Self
    ) -> RelateResult<'tcx, Self>
    where
        R: TypeRelation<'a, 'gcx, 'tcx>,
        'gcx: 'a + 'tcx,
        'tcx: 'a;
}

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Required Methods

fn relate<'a, 'gcx, R>(
    relation: &mut R,
    a: &Self,
    b: &Self
) -> RelateResult<'tcx, Self> where
    R: TypeRelation<'a, 'gcx, 'tcx>,
    'gcx: 'a + 'tcx,
    'tcx: 'a, 

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Implementations on Foreign Types

impl<'tcx> Relate<'tcx> for Abi

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Abi,     b: &Abi ) -> RelateResult<'tcx, Abi> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for Vec<PolyExistentialProjection<'tcx>>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Vec<PolyExistentialProjection<'tcx>>,     b: &Vec<PolyExistentialProjection<'tcx>> ) -> RelateResult<'tcx, Vec<PolyExistentialProjection<'tcx>>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Rc<T>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Rc<T>,     b: &Rc<T> ) -> RelateResult<'tcx, Rc<T>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Box<T>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Box<T>,     b: &Box<T> ) -> RelateResult<'tcx, Box<T>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Implementors

impl<'tcx> Relate<'tcx> for &'tcx List<ExistentialPredicate<'tcx>>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Self,     b: &Self ) -> RelateResult<'tcx, Self> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for &'tcx Substs<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &&'tcx Substs<'tcx>,     b: &&'tcx Substs<'tcx> ) -> RelateResult<'tcx, &'tcx Substs<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for Unsafety

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Unsafety,     b: &Unsafety ) -> RelateResult<'tcx, Unsafety> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &GeneratorWitness<'tcx>,     b: &GeneratorWitness<'tcx> ) -> RelateResult<'tcx, GeneratorWitness<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for ClosureSubsts<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &ClosureSubsts<'tcx>,     b: &ClosureSubsts<'tcx> ) -> RelateResult<'tcx, ClosureSubsts<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for ExistentialProjection<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &ExistentialProjection<'tcx>,     b: &ExistentialProjection<'tcx> ) -> RelateResult<'tcx, ExistentialProjection<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for ExistentialTraitRef<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &ExistentialTraitRef<'tcx>,     b: &ExistentialTraitRef<'tcx> ) -> RelateResult<'tcx, ExistentialTraitRef<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for FnSig<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &FnSig<'tcx>,     b: &FnSig<'tcx> ) -> RelateResult<'tcx, FnSig<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for GeneratorSubsts<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &GeneratorSubsts<'tcx>,     b: &GeneratorSubsts<'tcx> ) -> RelateResult<'tcx, GeneratorSubsts<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for ProjectionTy<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &ProjectionTy<'tcx>,     b: &ProjectionTy<'tcx> ) -> RelateResult<'tcx, ProjectionTy<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for TraitRef<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &TraitRef<'tcx>,     b: &TraitRef<'tcx> ) -> RelateResult<'tcx, TraitRef<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for TypeAndMut<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &TypeAndMut<'tcx>,     b: &TypeAndMut<'tcx> ) -> RelateResult<'tcx, TypeAndMut<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for Kind<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Kind<'tcx>,     b: &Kind<'tcx> ) -> RelateResult<'tcx, Kind<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for Region<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Region<'tcx>,     b: &Region<'tcx> ) -> RelateResult<'tcx, Region<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> Relate<'tcx> for Ty<'tcx>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Ty<'tcx>,     b: &Ty<'tcx> ) -> RelateResult<'tcx, Ty<'tcx>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<T>

fn relate<'a, 'gcx, R>(     relation: &mut R,     a: &Binder<T>,     b: &Binder<T> ) -> RelateResult<'tcx, Binder<T>> where     R: TypeRelation<'a, 'gcx, 'tcx>,     'gcx: 'a + 'tcx,     'tcx: 'a,

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

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?