[−][src]Struct chalk_ir::OpaqueTy

pub struct OpaqueTy<I: Interner> {
    pub opaque_ty_id: OpaqueTyId<I>,
    pub substitution: Substitution<I>,
}

Fields

opaque_ty_id: OpaqueTyIdsubstitution: Substitution

Implementations

`impl<I: Interner> OpaqueTy`[src]

`pub fn debug<'a>(&'a self, interner: &'a I) -> OpaqueTyDebug<'a, I>`[src]

Trait Implementations

`impl<I: Clone + Interner> Clone for OpaqueTy`[src]

`fn clone(&self) -> OpaqueTy`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<I: Interner> Debug for OpaqueTy`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<I: Eq + Interner> Eq for OpaqueTy`[src]

`impl<I: Interner, _TI> Fold<I, _TI> for OpaqueTy where _TI: TargetInterner,` [src]

`type Result = OpaqueTy<_TI>`

The type of value that will be produced once folding is done. Typically this is Self, unless Self contains borrowed values, in which case owned values are produced (for example, one can fold over a &T value where T: Fold, in which case you get back a T, not a &T). Read more

`fn fold_with<'i>( &self, folder: &mut dyn Folder<'i, I, _TI>, outer_binder: DebruijnIndex ) -> Fallible<Self::Result> where I: 'i, _TI: 'i,` [src]

`impl<I: Interner> HasInterner for OpaqueTy`[src]

`type Interner = I`

`impl<I: Hash + Interner> Hash for OpaqueTy`[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0[src]

`impl<I: PartialEq + Interner> PartialEq<OpaqueTy> for OpaqueTy`[src]

`fn eq(&self, other: &OpaqueTy) -> bool`[src]

`fn ne(&self, other: &OpaqueTy) -> bool`[src]

`impl<I: Interner> StructuralEq for OpaqueTy`[src]

`impl<I: Interner> StructuralPartialEq for OpaqueTy`[src]

`impl<I: Interner> Visit for OpaqueTy`[src]

`fn visit_with<'i, R: VisitResult>( &self, visitor: &mut dyn Visitor<'i, I, Result = R>, outer_binder: DebruijnIndex ) -> R where I: 'i,` [src]

`impl<I: Interner> Zip for OpaqueTy`[src]

`fn zip_with<'i, Z: Zipper<'i, I>>( zipper: &mut Z, a: &Self, b: &Self ) -> Fallible<()> where I: 'i,` [src]

Auto Trait Implementations

`impl RefUnwindSafe for OpaqueTy where ::DefId: RefUnwindSafe, ::InternedSubstitution: RefUnwindSafe,`

`impl Send for OpaqueTy where ::DefId: Send, ::InternedSubstitution: Send,`

`impl Sync for OpaqueTy where ::DefId: Sync, ::InternedSubstitution: Sync,`

`impl Unpin for OpaqueTy where ::DefId: Unpin, ::InternedSubstitution: Unpin,`

`impl UnwindSafe for OpaqueTy where ::DefId: UnwindSafe, ::InternedSubstitution: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Cast for T`[src]

`fn cast(self, interner: &U::Interner) -> U where Self: CastTo, U: HasInterner,` [src]

`impl<T, I> CouldMatch<T> for T where I: Interner, T: Zip + HasInterner<Interner = I> + ?Sized,` [src]

`fn could_match(&Self, &I, &T) -> bool`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, I> Shift for T where I: Interner, T: Fold<I, I>,` [src]

`fn shifted_in(&Self, &I) -> <T as Fold<I, I>>::Result`[src]

`fn shifted_in_from(&Self, &I, DebruijnIndex) -> <T as Fold<I, I>>::Result`[src]

`fn shifted_out_to( &Self, &I, DebruijnIndex ) -> Result<<T as Fold<I, I>>::Result, NoSolution>`[src]

`fn shifted_out(&Self, &I) -> Result<<T as Fold<I, I>>::Result, NoSolution>`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T, I> VisitExt for T where I: Interner, T: Visit,` [src]

`fn has_free_vars(&self, interner: &I) -> bool`[src]

[−][src]Struct chalk_ir::OpaqueTy

Fields

Implementations

impl<I: Interner> OpaqueTy<I>[src]

pub fn debug<'a>(&'a self, interner: &'a I) -> OpaqueTyDebug<'a, I>[src]

Trait Implementations

impl<I: Clone + Interner> Clone for OpaqueTy<I>[src]

fn clone(&self) -> OpaqueTy<I>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<I: Interner> Debug for OpaqueTy<I>[src]

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>[src]

impl<I: Eq + Interner> Eq for OpaqueTy<I>[src]

impl<I: Interner, _TI> Fold<I, _TI> for OpaqueTy<I> where _TI: TargetInterner<I>, [src]

type Result = OpaqueTy<_TI>

fn fold_with<'i>( &self, folder: &mut dyn Folder<'i, I, _TI>, outer_binder: DebruijnIndex) -> Fallible<Self::Result> where I: 'i, _TI: 'i, [src]

impl<I: Interner> HasInterner for OpaqueTy<I>[src]

type Interner = I

impl<I: Hash + Interner> Hash for OpaqueTy<I>[src]

fn hash<__H: Hasher>(&self, state: &mut __H)[src]

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher, 1.3.0[src]

impl<I: PartialEq + Interner> PartialEq<OpaqueTy<I>> for OpaqueTy<I>[src]

fn eq(&self, other: &OpaqueTy<I>) -> bool[src]

fn ne(&self, other: &OpaqueTy<I>) -> bool[src]

impl<I: Interner> StructuralEq for OpaqueTy<I>[src]

impl<I: Interner> StructuralPartialEq for OpaqueTy<I>[src]

impl<I: Interner> Visit<I> for OpaqueTy<I>[src]

fn visit_with<'i, R: VisitResult>( &self, visitor: &mut dyn Visitor<'i, I, Result = R>, outer_binder: DebruijnIndex) -> R where I: 'i, [src]

impl<I: Interner> Zip<I> for OpaqueTy<I>[src]

fn zip_with<'i, Z: Zipper<'i, I>>( zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()> where I: 'i, [src]

Auto Trait Implementations

impl<I> RefUnwindSafe for OpaqueTy<I> where <I as Interner>::DefId: RefUnwindSafe, <I as Interner>::InternedSubstitution: RefUnwindSafe,

impl<I> Send for OpaqueTy<I> where <I as Interner>::DefId: Send, <I as Interner>::InternedSubstitution: Send,

impl<I> Sync for OpaqueTy<I> where <I as Interner>::DefId: Sync, <I as Interner>::InternedSubstitution: Sync,

impl<I> Unpin for OpaqueTy<I> where <I as Interner>::DefId: Unpin, <I as Interner>::InternedSubstitution: Unpin,

impl<I> UnwindSafe for OpaqueTy<I> where <I as Interner>::DefId: UnwindSafe, <I as Interner>::InternedSubstitution: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Cast for T[src]

fn cast<U>(self, interner: &U::Interner) -> U where Self: CastTo<U>, U: HasInterner, [src]

impl<T, I> CouldMatch<T> for T where I: Interner, T: Zip<I> + HasInterner<Interner = I> + ?Sized, [src]

fn could_match(&Self, &I, &T) -> bool[src]

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T, I> Shift<I> for T where I: Interner, T: Fold<I, I>, [src]

fn shifted_in(&Self, &I) -> <T as Fold<I, I>>::Result[src]

fn shifted_in_from(&Self, &I, DebruijnIndex) -> <T as Fold<I, I>>::Result[src]

fn shifted_out_to( &Self, &I, DebruijnIndex) -> Result<<T as Fold<I, I>>::Result, NoSolution>[src]

fn shifted_out(&Self, &I) -> Result<<T as Fold<I, I>>::Result, NoSolution>[src]

impl<T> ToOwned for T where T: Clone, [src]

type Owned = T

fn to_owned(&self) -> T[src]

fn clone_into(&self, target: &mut T)[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

impl<T, I> VisitExt<I> for T where I: Interner, T: Visit<I>, [src]

fn has_free_vars(&self, interner: &I) -> bool[src]

`impl<I: Interner> OpaqueTy<I>`[src]

`pub fn debug<'a>(&'a self, interner: &'a I) -> OpaqueTyDebug<'a, I>`[src]

`impl<I: Clone + Interner> Clone for OpaqueTy<I>`[src]

`fn clone(&self) -> OpaqueTy<I>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<I: Interner> Debug for OpaqueTy<I>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<I: Eq + Interner> Eq for OpaqueTy<I>`[src]

`impl<I: Interner, _TI> Fold<I, _TI> for OpaqueTy<I> where _TI: TargetInterner<I>,` [src]

`type Result = OpaqueTy<_TI>`

`fn fold_with<'i>( &self, folder: &mut dyn Folder<'i, I, _TI>, outer_binder: DebruijnIndex ) -> Fallible<Self::Result> where I: 'i, _TI: 'i,` [src]

`impl<I: Interner> HasInterner for OpaqueTy<I>`[src]

`type Interner = I`

`impl<I: Hash + Interner> Hash for OpaqueTy<I>`[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0[src]

`impl<I: PartialEq + Interner> PartialEq<OpaqueTy<I>> for OpaqueTy<I>`[src]

`fn eq(&self, other: &OpaqueTy<I>) -> bool`[src]

`fn ne(&self, other: &OpaqueTy<I>) -> bool`[src]

`impl<I: Interner> StructuralEq for OpaqueTy<I>`[src]

`impl<I: Interner> StructuralPartialEq for OpaqueTy<I>`[src]

`impl<I: Interner> Visit<I> for OpaqueTy<I>`[src]

`fn visit_with<'i, R: VisitResult>( &self, visitor: &mut dyn Visitor<'i, I, Result = R>, outer_binder: DebruijnIndex ) -> R where I: 'i,` [src]

`impl<I: Interner> Zip<I> for OpaqueTy<I>`[src]

`fn zip_with<'i, Z: Zipper<'i, I>>( zipper: &mut Z, a: &Self, b: &Self ) -> Fallible<()> where I: 'i,` [src]

`impl<I> RefUnwindSafe for OpaqueTy<I> where <I as Interner>::DefId: RefUnwindSafe, <I as Interner>::InternedSubstitution: RefUnwindSafe,`

`impl<I> Send for OpaqueTy<I> where <I as Interner>::DefId: Send, <I as Interner>::InternedSubstitution: Send,`

`impl<I> Sync for OpaqueTy<I> where <I as Interner>::DefId: Sync, <I as Interner>::InternedSubstitution: Sync,`

`impl<I> Unpin for OpaqueTy<I> where <I as Interner>::DefId: Unpin, <I as Interner>::InternedSubstitution: Unpin,`

`impl<I> UnwindSafe for OpaqueTy<I> where <I as Interner>::DefId: UnwindSafe, <I as Interner>::InternedSubstitution: UnwindSafe,`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Cast for T`[src]

`fn cast<U>(self, interner: &U::Interner) -> U where Self: CastTo<U>, U: HasInterner,` [src]

`impl<T, I> CouldMatch<T> for T where I: Interner, T: Zip<I> + HasInterner<Interner = I> + ?Sized,` [src]

`fn could_match(&Self, &I, &T) -> bool`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, I> Shift<I> for T where I: Interner, T: Fold<I, I>,` [src]

`fn shifted_in(&Self, &I) -> <T as Fold<I, I>>::Result`[src]

`fn shifted_in_from(&Self, &I, DebruijnIndex) -> <T as Fold<I, I>>::Result`[src]

`fn shifted_out_to( &Self, &I, DebruijnIndex ) -> Result<<T as Fold<I, I>>::Result, NoSolution>`[src]

`fn shifted_out(&Self, &I) -> Result<<T as Fold<I, I>>::Result, NoSolution>`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

`impl<T, I> VisitExt<I> for T where I: Interner, T: Visit<I>,` [src]

`fn has_free_vars(&self, interner: &I) -> bool`[src]