Trait rustc_middle::ty::relate::Relate[][src]

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

Required methods

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Self,
    b: Self
) -> RelateResult<'tcx, Self>
[src]

Loading content...

Implementations on Foreign Types

impl<'tcx> Relate<'tcx> for Unsafety[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Unsafety,
    b: Unsafety
) -> RelateResult<'tcx, Unsafety>
[src]

impl<'tcx> Relate<'tcx> for Abi[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Abi,
    b: Abi
) -> RelateResult<'tcx, Abi>
[src]

Loading content...

Implementors

impl<'tcx> Relate<'tcx> for &'tcx Const<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: &'tcx Const<'tcx>,
    b: &'tcx Const<'tcx>
) -> RelateResult<'tcx, &'tcx Const<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for &'tcx List<Binder<'tcx, ExistentialPredicate<'tcx>>>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Self,
    b: Self
) -> RelateResult<'tcx, Self>
[src]

impl<'tcx> Relate<'tcx> for ProjectionPredicate<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ProjectionPredicate<'tcx>,
    b: ProjectionPredicate<'tcx>
) -> RelateResult<'tcx, ProjectionPredicate<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for TraitPredicate<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TraitPredicate<'tcx>,
    b: TraitPredicate<'tcx>
) -> RelateResult<'tcx, TraitPredicate<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for ClosureSubsts<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ClosureSubsts<'tcx>,
    b: ClosureSubsts<'tcx>
) -> RelateResult<'tcx, ClosureSubsts<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for ExistentialProjection<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ExistentialProjection<'tcx>,
    b: ExistentialProjection<'tcx>
) -> RelateResult<'tcx, ExistentialProjection<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for ExistentialTraitRef<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ExistentialTraitRef<'tcx>,
    b: ExistentialTraitRef<'tcx>
) -> RelateResult<'tcx, ExistentialTraitRef<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for FnSig<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: FnSig<'tcx>,
    b: FnSig<'tcx>
) -> RelateResult<'tcx, FnSig<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for GeneratorSubsts<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GeneratorSubsts<'tcx>,
    b: GeneratorSubsts<'tcx>
) -> RelateResult<'tcx, GeneratorSubsts<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for ProjectionTy<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ProjectionTy<'tcx>,
    b: ProjectionTy<'tcx>
) -> RelateResult<'tcx, ProjectionTy<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for TraitRef<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TraitRef<'tcx>,
    b: TraitRef<'tcx>
) -> RelateResult<'tcx, TraitRef<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for TypeAndMut<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TypeAndMut<'tcx>,
    b: TypeAndMut<'tcx>
) -> RelateResult<'tcx, TypeAndMut<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for GenericArg<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GenericArg<'tcx>,
    b: GenericArg<'tcx>
) -> RelateResult<'tcx, GenericArg<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GeneratorWitness<'tcx>,
    b: GeneratorWitness<'tcx>
) -> RelateResult<'tcx, GeneratorWitness<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for Region<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Region<'tcx>,
    b: Region<'tcx>
) -> RelateResult<'tcx, Region<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for SubstsRef<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: SubstsRef<'tcx>,
    b: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>
[src]

impl<'tcx> Relate<'tcx> for Ty<'tcx>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Ty<'tcx>,
    b: Ty<'tcx>
) -> RelateResult<'tcx, Ty<'tcx>>
[src]

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<'tcx, T>[src]

fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Binder<'tcx, T>,
    b: Binder<'tcx, T>
) -> RelateResult<'tcx, Binder<'tcx, T>>
[src]

Loading content...