Trait Ty

pub trait Ty<I>:
    Copy
    + Debug
    + Hash
    + Eq
    + Into<<I as Interner>::GenericArg>
    + Into<<I as Interner>::Term>
    + IntoKind<Kind = TyKind<I>>
    + TypeSuperVisitable<I>
    + TypeSuperFoldable<I>
    + Relate<I>
    + Flags
where
    I: Interner<Ty = Self>,
{
    // Required methods
    fn new_unit(interner: I) -> Self;
    fn new_bool(interner: I) -> Self;
    fn new_u8(interner: I) -> Self;
    fn new_usize(interner: I) -> Self;
    fn new_infer(interner: I, var: InferTy) -> Self;
    fn new_var(interner: I, var: TyVid) -> Self;
    fn new_param(interner: I, param: <I as Interner>::ParamTy) -> Self;
    fn new_placeholder(
        interner: I,
        param: <I as Interner>::PlaceholderTy,
    ) -> Self;
    fn new_bound(
        interner: I,
        debruijn: DebruijnIndex,
        var: <I as Interner>::BoundTy,
    ) -> Self;
    fn new_anon_bound(
        interner: I,
        debruijn: DebruijnIndex,
        var: BoundVar,
    ) -> Self;
    fn new_alias(interner: I, kind: AliasTyKind, alias_ty: AliasTy<I>) -> Self;
    fn new_error(interner: I, guar: <I as Interner>::ErrorGuaranteed) -> Self;
    fn new_adt(
        interner: I,
        adt_def: <I as Interner>::AdtDef,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_foreign(interner: I, def_id: <I as Interner>::DefId) -> Self;
    fn new_dynamic(
        interner: I,
        preds: <I as Interner>::BoundExistentialPredicates,
        region: <I as Interner>::Region,
        kind: DynKind,
    ) -> Self;
    fn new_coroutine(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_coroutine_closure(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_closure(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_coroutine_witness(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_ptr(interner: I, ty: Self, mutbl: Mutability) -> Self;
    fn new_ref(
        interner: I,
        region: <I as Interner>::Region,
        ty: Self,
        mutbl: Mutability,
    ) -> Self;
    fn new_array_with_const_len(
        interner: I,
        ty: Self,
        len: <I as Interner>::Const,
    ) -> Self;
    fn new_slice(interner: I, ty: Self) -> Self;
    fn new_tup(interner: I, tys: &[Self]) -> Self;
    fn new_tup_from_iter<It, T>(
        interner: I,
        iter: It,
    ) -> <T as CollectAndApply<Self, Self>>::Output
       where It: Iterator<Item = T>,
             T: CollectAndApply<Self, Self>;
    fn new_fn_def(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self;
    fn new_fn_ptr(interner: I, sig: Binder<I, FnSig<I>>) -> Self;
    fn new_pat(interner: I, ty: Self, pat: <I as Interner>::Pat) -> Self;
    fn tuple_fields(self) -> <I as Interner>::Tys;
    fn to_opt_closure_kind(self) -> Option<ClosureKind>;
    fn from_closure_kind(interner: I, kind: ClosureKind) -> Self;
    fn from_coroutine_closure_kind(interner: I, kind: ClosureKind) -> Self;
    fn discriminant_ty(self, interner: I) -> Self;
    fn async_destructor_ty(self, interner: I) -> Self;

    // Provided methods
    fn new_projection_from_args(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: <I as Interner>::GenericArgs,
    ) -> Self { ... }
    fn new_projection(
        interner: I,
        def_id: <I as Interner>::DefId,
        args: impl IntoIterator>,
    ) -> Self
       where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg> { ... }
    fn is_ty_var(self) -> bool { ... }
    fn is_floating_point(self) -> bool { ... }
    fn is_integral(self) -> bool { ... }
    fn is_fn_ptr(self) -> bool { ... }
    fn fn_sig(self, interner: I) -> Binder<I, FnSig<I>> { ... }
    fn is_known_rigid(self) -> bool { ... }
}

Required Methods

fn new_unit(interner: I) -> Self

fn new_bool(interner: I) -> Self

fn new_u8(interner: I) -> Self

fn new_usize(interner: I) -> Self

fn new_infer(interner: I, var: InferTy) -> Self

fn new_var(interner: I, var: TyVid) -> Self

fn new_param(interner: I, param: <I as Interner>::ParamTy) -> Self

fn new_placeholder(interner: I, param: <I as Interner>::PlaceholderTy) -> Self

fn new_bound( interner: I, debruijn: DebruijnIndex, var: <I as Interner>::BoundTy, ) -> Self

fn new_anon_bound(interner: I, debruijn: DebruijnIndex, var: BoundVar) -> Self

fn new_alias(interner: I, kind: AliasTyKind, alias_ty: AliasTy<I>) -> Self

fn new_error(interner: I, guar: <I as Interner>::ErrorGuaranteed) -> Self

fn new_adt( interner: I, adt_def: <I as Interner>::AdtDef, args: <I as Interner>::GenericArgs, ) -> Self

fn new_foreign(interner: I, def_id: <I as Interner>::DefId) -> Self

fn new_dynamic( interner: I, preds: <I as Interner>::BoundExistentialPredicates, region: <I as Interner>::Region, kind: DynKind, ) -> Self

fn new_coroutine( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_coroutine_closure( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_closure( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_coroutine_witness( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_ptr(interner: I, ty: Self, mutbl: Mutability) -> Self

fn new_ref( interner: I, region: <I as Interner>::Region, ty: Self, mutbl: Mutability, ) -> Self

fn new_array_with_const_len( interner: I, ty: Self, len: <I as Interner>::Const, ) -> Self

fn new_slice(interner: I, ty: Self) -> Self

fn new_tup(interner: I, tys: &[Self]) -> Self

fn new_tup_from_iter<It, T>( interner: I, iter: It, ) -> <T as CollectAndApply<Self, Self>>::Output

where It: Iterator<Item = T>, T: CollectAndApply<Self, Self>,

fn new_fn_def( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_fn_ptr(interner: I, sig: Binder<I, FnSig<I>>) -> Self

fn new_pat(interner: I, ty: Self, pat: <I as Interner>::Pat) -> Self

fn tuple_fields(self) -> <I as Interner>::Tys

fn to_opt_closure_kind(self) -> Option<ClosureKind>

fn from_closure_kind(interner: I, kind: ClosureKind) -> Self

fn from_coroutine_closure_kind(interner: I, kind: ClosureKind) -> Self

fn discriminant_ty(self, interner: I) -> Self

fn async_destructor_ty(self, interner: I) -> Self

Provided Methods

fn new_projection_from_args( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_projection( interner: I, def_id: <I as Interner>::DefId, args: impl IntoIterator>, ) -> Self

where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg>,

fn is_ty_var(self) -> bool

fn is_floating_point(self) -> bool

fn is_integral(self) -> bool

fn is_fn_ptr(self) -> bool

fn fn_sig(self, interner: I) -> Binder<I, FnSig<I>>

fn is_known_rigid(self) -> bool

Returns true when the outermost type cannot be further normalized, resolved, or instantiated. This includes all primitive types, but also things like ADTs and trait objects, since even if their arguments or nested types may be further simplified, the outermost ty::TyKind or type constructor remains the same.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'tcx> Ty<TyCtxt<'tcx>> for Ty<'tcx>

fn new_bool(tcx: TyCtxt<'tcx>) -> Ty<'tcx>

fn new_u8(tcx: TyCtxt<'tcx>) -> Ty<'tcx>

fn new_infer(tcx: TyCtxt<'tcx>, infer: InferTy) -> Ty<'tcx>

fn new_var(tcx: TyCtxt<'tcx>, vid: TyVid) -> Ty<'tcx>

fn new_param(tcx: TyCtxt<'tcx>, param: ParamTy) -> Ty<'tcx>

fn new_placeholder( tcx: TyCtxt<'tcx>, placeholder: Placeholder<BoundTy>, ) -> Ty<'tcx>

fn new_bound( interner: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundTy, ) -> Ty<'tcx>

fn new_anon_bound( tcx: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundVar, ) -> Ty<'tcx>

fn new_alias( interner: TyCtxt<'tcx>, kind: AliasTyKind, alias_ty: AliasTy<TyCtxt<'tcx>>, ) -> Ty<'tcx>

fn new_error(interner: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Ty<'tcx>

fn new_adt( interner: TyCtxt<'tcx>, adt_def: AdtDef<'tcx>, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_foreign(interner: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx>

fn new_dynamic( interner: TyCtxt<'tcx>, preds: &'tcx RawList<(), Binder<TyCtxt<'tcx>, ExistentialPredicate<TyCtxt<'tcx>>>>, region: Region<'tcx>, kind: DynKind, ) -> Ty<'tcx>

fn new_coroutine( interner: TyCtxt<'tcx>, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_coroutine_closure( interner: TyCtxt<'tcx>, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_closure( interner: TyCtxt<'tcx>, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_coroutine_witness( interner: TyCtxt<'tcx>, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_ptr(interner: TyCtxt<'tcx>, ty: Ty<'tcx>, mutbl: Mutability) -> Ty<'tcx>

fn new_ref( interner: TyCtxt<'tcx>, region: Region<'tcx>, ty: Ty<'tcx>, mutbl: Mutability, ) -> Ty<'tcx>

fn new_array_with_const_len( interner: TyCtxt<'tcx>, ty: Ty<'tcx>, len: Const<'tcx>, ) -> Ty<'tcx>

fn new_slice(interner: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>

fn new_tup(interner: TyCtxt<'tcx>, tys: &[Ty<'tcx>]) -> Ty<'tcx>

fn new_tup_from_iter<It, T>( interner: TyCtxt<'tcx>, iter: It, ) -> <T as CollectAndApply<Ty<'tcx>, Ty<'tcx>>>::Output

where It: Iterator<Item = T>, T: CollectAndApply<Ty<'tcx>, Ty<'tcx>>,

fn tuple_fields(self) -> &'tcx RawList<(), Ty<'tcx>>

fn to_opt_closure_kind(self) -> Option<ClosureKind>

fn from_closure_kind(interner: TyCtxt<'tcx>, kind: ClosureKind) -> Ty<'tcx>

fn from_coroutine_closure_kind( interner: TyCtxt<'tcx>, kind: ClosureKind, ) -> Ty<'tcx>

fn new_fn_def( interner: TyCtxt<'tcx>, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> Ty<'tcx>

fn new_fn_ptr( interner: TyCtxt<'tcx>, sig: Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>, ) -> Ty<'tcx>

fn new_pat(interner: TyCtxt<'tcx>, ty: Ty<'tcx>, pat: Pattern<'tcx>) -> Ty<'tcx>

fn new_unit(interner: TyCtxt<'tcx>) -> Ty<'tcx>

fn new_usize(interner: TyCtxt<'tcx>) -> Ty<'tcx>

fn discriminant_ty(self, interner: TyCtxt<'tcx>) -> Ty<'tcx>

fn async_destructor_ty(self, interner: TyCtxt<'tcx>) -> Ty<'tcx>

Implementors