[−][src]Enum chalk_ir::ProgramClauseData

pub enum ProgramClauseData<I: Interner> {
    Implies(ProgramClauseImplication<I>),
    ForAll(Binders<ProgramClauseImplication<I>>),
}

Variants

Implies(ProgramClauseImplication)

ForAll(Binders<ProgramClauseImplication>)

Implementations

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

`pub fn into_from_env_clause(self, interner: &I) -> ProgramClauseData`[src]

`pub fn intern(self, interner: &I) -> ProgramClause`[src]

Trait Implementations

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

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

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

`impl<I: Interner> CouldMatch<DomainGoal> for ProgramClauseData`[src]

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

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

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

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

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

`type Result = ProgramClauseData<_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 ProgramClauseData`[src]

`type Interner = I`

`impl<I: Hash + Interner> Hash for ProgramClauseData`[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<ProgramClauseData> for ProgramClauseData`[src]

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

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

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

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

`impl<I: Interner, TI: TargetInterner> SuperFold<I, TI> for ProgramClauseData`[src]

`fn super_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> Zip for ProgramClauseData`[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 ProgramClauseData where ::DefId: RefUnwindSafe, ::InternedGoals: RefUnwindSafe, ::InternedLifetime: RefUnwindSafe, ::InternedSubstitution: RefUnwindSafe, ::InternedType: RefUnwindSafe, ::InternedVariableKinds: RefUnwindSafe,`

`impl Send for ProgramClauseData where ::DefId: Send, ::InternedGoals: Send, ::InternedLifetime: Send, ::InternedSubstitution: Send, ::InternedType: Send, ::InternedVariableKinds: Send,`

`impl Sync for ProgramClauseData where ::DefId: Sync, ::InternedGoals: Sync, ::InternedLifetime: Sync, ::InternedSubstitution: Sync, ::InternedType: Sync, ::InternedVariableKinds: Sync,`

`impl Unpin for ProgramClauseData where ::DefId: Unpin, ::InternedGoals: Unpin, ::InternedLifetime: Unpin, ::InternedSubstitution: Unpin, ::InternedType: Unpin, ::InternedVariableKinds: Unpin,`

`impl UnwindSafe for ProgramClauseData where ::DefId: UnwindSafe, ::InternedGoals: UnwindSafe, ::InternedLifetime: UnwindSafe, ::InternedSubstitution: UnwindSafe, ::InternedType: UnwindSafe, ::InternedVariableKinds: 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]

[−][src]Enum chalk_ir::ProgramClauseData

Variants

Implementations

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

pub fn into_from_env_clause(self, interner: &I) -> ProgramClauseData<I>[src]

pub fn intern(self, interner: &I) -> ProgramClause<I>[src]

Trait Implementations

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

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

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

impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClauseData<I>[src]

fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool[src]

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

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

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

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

type Result = ProgramClauseData<_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 ProgramClauseData<I>[src]

type Interner = I

impl<I: Hash + Interner> Hash for ProgramClauseData<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<ProgramClauseData<I>> for ProgramClauseData<I>[src]

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

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

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

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

impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I>[src]

fn super_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> Zip<I> for ProgramClauseData<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> Send for ProgramClauseData<I> where <I as Interner>::DefId: Send, <I as Interner>::InternedGoals: Send, <I as Interner>::InternedLifetime: Send, <I as Interner>::InternedSubstitution: Send, <I as Interner>::InternedType: Send, <I as Interner>::InternedVariableKinds: Send,

impl<I> Sync for ProgramClauseData<I> where <I as Interner>::DefId: Sync, <I as Interner>::InternedGoals: Sync, <I as Interner>::InternedLifetime: Sync, <I as Interner>::InternedSubstitution: Sync, <I as Interner>::InternedType: Sync, <I as Interner>::InternedVariableKinds: Sync,

impl<I> Unpin for ProgramClauseData<I> where <I as Interner>::DefId: Unpin, <I as Interner>::InternedGoals: Unpin, <I as Interner>::InternedLifetime: Unpin, <I as Interner>::InternedSubstitution: Unpin, <I as Interner>::InternedType: Unpin, <I as Interner>::InternedVariableKinds: Unpin,

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<I: Interner> ProgramClauseData<I>`[src]

`pub fn into_from_env_clause(self, interner: &I) -> ProgramClauseData<I>`[src]

`pub fn intern(self, interner: &I) -> ProgramClause<I>`[src]

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

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

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

`impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClauseData<I>`[src]

`fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool`[src]

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

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

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

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

`type Result = ProgramClauseData<_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 ProgramClauseData<I>`[src]

`type Interner = I`

`impl<I: Hash + Interner> Hash for ProgramClauseData<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<ProgramClauseData<I>> for ProgramClauseData<I>`[src]

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

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

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

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

`impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I>`[src]

`fn super_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> Zip<I> for ProgramClauseData<I>`[src]

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

`impl<I> Send for ProgramClauseData<I> where <I as Interner>::DefId: Send, <I as Interner>::InternedGoals: Send, <I as Interner>::InternedLifetime: Send, <I as Interner>::InternedSubstitution: Send, <I as Interner>::InternedType: Send, <I as Interner>::InternedVariableKinds: Send,`

`impl<I> Sync for ProgramClauseData<I> where <I as Interner>::DefId: Sync, <I as Interner>::InternedGoals: Sync, <I as Interner>::InternedLifetime: Sync, <I as Interner>::InternedSubstitution: Sync, <I as Interner>::InternedType: Sync, <I as Interner>::InternedVariableKinds: Sync,`

`impl<I> Unpin for ProgramClauseData<I> where <I as Interner>::DefId: Unpin, <I as Interner>::InternedGoals: Unpin, <I as Interner>::InternedLifetime: Unpin, <I as Interner>::InternedSubstitution: Unpin, <I as Interner>::InternedType: Unpin, <I as Interner>::InternedVariableKinds: Unpin,`

`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]