fixed protocols
| -rw-r--r-- | src/protocol.rs | 87 | ||||
| -rw-r--r-- | src/protocol/visitor/request_hint.rs | 2 | ||||
| -rw-r--r-- | src/protocol/visitor/sequence.rs | 31 | ||||
| -rw-r--r-- | src/protocol/visitor/tagged.rs | 29 | ||||
| -rw-r--r-- | src/protocol/visitor/value.rs | 67 | ||||
| -rw-r--r-- | src/protocol/walker/hint.rs | 35 |
6 files changed, 111 insertions, 140 deletions
diff --git a/src/protocol.rs b/src/protocol.rs index c4a7f7a..7ff6988 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -42,37 +42,21 @@ use core::{ }; use crate::any::AnyTrait; +use crate::hkt::{type_class, hkt}; -// pub mod visitor; -// pub mod walker; +pub mod visitor; +pub mod walker; #[cfg(all(feature = "alloc", not(feature = "std")))] use alloc::boxed::Box; -pub type Visitor<'a, 'ctx, Effect> = <<Effect as self::Effect<'ctx>>::VisitorHkt as ForLtAnyTraitSendObj<'a, 'ctx, Bound<'a, 'ctx>>>::T; -pub type Walker<'a, 'ctx, Effect> = <<Effect as self::Effect<'ctx>>::WalkerHkt as ForLtAnyTraitSendObj<'a, 'ctx, Bound<'a, 'ctx>>>::T; +pub type Visitor<'a, 'ctx, Effect> = any_trait_send_obj::T<'a, 'ctx, <Effect as self::Effect<'ctx>>::VisitorHkt>; +pub type Walker<'a, 'ctx, Effect> = any_trait_send_obj::T<'a, 'ctx, <Effect as self::Effect<'ctx>>::WalkerHkt>; pub trait AnyTraitObj<'a, 'ctx: 'a>: AnyTraitSendObj<'a, 'ctx> { fn from_obj(value: &'a mut (dyn AnyTrait<'ctx> + 'a)) -> Self; } -// Lifetime bound to be used in `for<'lt>` blocks. -pub type Bound<'lt, 'bound> = &'lt &'bound (); - -pub trait ForLtAnyTraitSendObj<'lt, 'ctx: 'lt, B> { - type T: AnyTraitSendObj<'lt, 'ctx>; -} - -pub trait HktAnyTraitSendObj<'ctx>: for<'lt> ForLtAnyTraitSendObj<'lt, 'ctx, Bound<'lt, 'ctx>> {} -impl<'ctx, T> HktAnyTraitSendObj<'ctx> for T where T: for<'lt> ForLtAnyTraitSendObj<'lt, 'ctx, Bound<'lt, 'ctx>> {} - -pub trait ForLt<'lt, 'ctx: 'lt, B> { - type T; -} - -pub trait Hkt<'ctx>: for<'lt> ForLt<'lt, 'ctx, Bound<'lt, 'ctx>> {} -impl<'ctx, T> Hkt<'ctx> for T where T: for<'lt> ForLt<'lt, 'ctx, Bound<'lt, 'ctx>> {} - pub trait AnyTraitSendObj<'a, 'ctx: 'a> { fn from_obj_send(value: &'a mut (dyn AnyTrait<'ctx> + Send + 'a)) -> Self; fn as_obj(&self) -> &dyn AnyTrait<'ctx>; @@ -122,71 +106,46 @@ impl<'a, 'ctx: 'a> AnyTraitObj<'a, 'ctx> for &'a mut (dyn AnyTrait<'ctx> + 'a) { } } +type_class!(for<'lt, 'ctx> pub any_trait_send_obj: AnyTraitSendObj<'lt, 'ctx>); +type_class!(for<'lt, 'ctx> pub any_t); + pub trait Effect<'ctx, C = (), B = ()>: 'static { - type VisitorHkt: HktAnyTraitSendObj<'ctx>; - type WalkerHkt: HktAnyTraitSendObj<'ctx>; - type ControlFlowHkt: Hkt<'ctx>; + type VisitorHkt: any_trait_send_obj::Hkt<'ctx>; + type WalkerHkt: any_trait_send_obj::Hkt<'ctx>; + type ControlFlowHkt: any_t::Hkt<'ctx>; } pub type ControlFlowFor<'a, 'ctx, E = SyncEffect, C = (), B = ()> = - <<E as Effect<'ctx, C, B>>::ControlFlowHkt as ForLt<'a, 'ctx, Bound<'a, 'ctx>>>::T; + any_t::T<'a, 'ctx, <E as Effect<'ctx, C, B>>::ControlFlowHkt>; pub enum SyncEffect {} -pub struct AnyTraitSendObjHkt<'ctx>(PhantomData<fn() -> &'ctx ()>); +hkt!((any_trait_send_obj): for<'a, 'ctx> pub AnyTraitSendObjHkt => &'a mut (dyn AnyTrait<'ctx> + Send + 'a)); +hkt!((any_trait_send_obj): for<'a, 'ctx> pub AnyTraitObjHkt => &'a mut (dyn AnyTrait<'ctx> + 'a)); -impl<'a, 'ctx> ForLtAnyTraitSendObj<'a, 'ctx, Bound<'a, 'ctx>> for AnyTraitSendObjHkt<'ctx> { - type T = &'a mut (dyn AnyTrait<'ctx> + Send + 'a); -} - -pub struct AnyTraitObjHkt<'ctx>(PhantomData<fn() -> &'ctx ()>); - -impl<'a, 'ctx> ForLtAnyTraitSendObj<'a, 'ctx, Bound<'a, 'ctx>> for AnyTraitObjHkt<'ctx> { - type T = &'a mut (dyn AnyTrait<'ctx> + 'a); -} - -pub struct SyncControlFlowHkt<'ctx, C, B>(PhantomData<fn() -> (&'ctx (), C, B)>); - -impl<'a, 'ctx, C, B> ForLt<'a, 'ctx, Bound<'a, 'ctx>> for SyncControlFlowHkt<'ctx, C, B> { - type T = core::ops::ControlFlow<B, C>; -} +hkt!((any_t): for<'a, 'ctx> pub SyncControlFlowHkt[C, B] => core::ops::ControlFlow<B, C>); impl<'ctx, C, B> Effect<'ctx, C, B> for SyncEffect { type ControlFlowHkt = SyncControlFlowHkt<'ctx, C, B>; - type VisitorHkt = AnyTraitSendObjHkt<'ctx>; - - type WalkerHkt = AnyTraitSendObjHkt<'ctx>; -} - -macro_rules! hkt { - (for<$lt:lifetime bound by $bound:lifetime> $name:ident$([$($generic:tt)*])? = $($type:tt)*) => { - pub struct $name<$bound $(, $($generic)*)?>(core::marker::PhantomData<fn() -> (&$bound () $(, $($generic)*)?)>); + type VisitorHkt = AnyTraitObjHkt<'ctx>; - impl<$lt, $bound $(, $($generic)*)?> crate::protocol::ForLt<$lt, $bound, Bound<$lt, $bound>> for $name<$bound $(, $($generic)*)?> { - type T = $($type)*; - } - } + type WalkerHkt = AnyTraitObjHkt<'ctx>; } -hkt!(for<'a bound by 'ctx> Demo = &'a &'ctx ()); - #[cfg(feature = "alloc")] -pub struct AsyncControlFlowHkt<'ctx, C, B>(PhantomData<fn() -> (&'ctx (), C, B)>); - -#[cfg(feature = "alloc")] -impl<'a, 'ctx, C, B> ForLt<'a, 'ctx, Bound<'a, 'ctx>> for AsyncControlFlowHkt<'ctx, C, B> { - type T = core::pin::Pin< +hkt!((any_t): for<'a, 'ctx> pub AsyncControlFlowHkt[C, B] => + core::pin::Pin< Box<dyn core::future::Future<Output = core::ops::ControlFlow<B, C>> + Send + 'a>, - >; -} + > +); #[cfg(feature = "alloc")] pub enum AsyncEffect {} #[cfg(feature = "alloc")] impl<'ctx, C, B> Effect<'ctx, C, B> for AsyncEffect { - type VisitorHkt = AnyTraitObjHkt<'ctx>; - type WalkerHkt = AnyTraitObjHkt<'ctx>; + type VisitorHkt = AnyTraitSendObjHkt<'ctx>; + type WalkerHkt = AnyTraitSendObjHkt<'ctx>; type ControlFlowHkt = AsyncControlFlowHkt<'ctx, C, B>; } diff --git a/src/protocol/visitor/request_hint.rs b/src/protocol/visitor/request_hint.rs index 772a908..bf0ba98 100644 --- a/src/protocol/visitor/request_hint.rs +++ b/src/protocol/visitor/request_hint.rs @@ -13,7 +13,7 @@ pub trait RequestHint<'a, 'ctx: 'a, E: Effect<'ctx> = SyncEffect> { } nameable! { - pub struct Name['a, 'ctx: 'a, E]; + pub struct Name['a, 'ctx, E]; impl [E] for dyn RequestHint<'a, 'ctx, E> + 'a where { E: Effect<'ctx>, 'ctx: 'a diff --git a/src/protocol/visitor/sequence.rs b/src/protocol/visitor/sequence.rs index d1b16d9..47ea03e 100644 --- a/src/protocol/visitor/sequence.rs +++ b/src/protocol/visitor/sequence.rs @@ -1,34 +1,35 @@ use crate::{ nameable, - protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect, Visitor}, + protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect, Visitor, any_t}, + hkt::hkt }; -pub trait Sequence<'a, 'ctx: 'a, E: Effect<'ctx> = SyncEffect> { - fn visit( +pub trait Sequence<'ctx, E: Effect<'ctx> = SyncEffect> { + fn visit<'a>( &'a mut self, - scope: &'a mut dyn for<'b> SequenceScope<'b, 'ctx, E>, - ) -> ControlFlowFor<'a, 'ctx, E>; + scope: &'a mut dyn SequenceScope<'ctx, E>, + ) -> ControlFlowFor<'a, 'ctx, E> where 'ctx: 'a; } nameable! { - pub struct Name['a, 'ctx: 'a, E]; + pub struct Name['a, 'ctx, E]; - impl [E] for dyn Sequence<'a, 'ctx, E> + 'a where { - E: Effect<'ctx>, + impl [E] for dyn Sequence<'ctx, E> + 'a where { + E: Effect<'ctx> + Effect<'ctx, Status>, 'ctx: 'a } - impl [E] where dyn Sequence<'a, 'ctx, E> + 'a { - E: Effect<'ctx>, + impl [E] where dyn Sequence<'ctx, E> + 'a { + E: Effect<'ctx> + Effect<'ctx, Status>, 'ctx: 'a } } -pub trait SequenceScope<'a, 'ctx: 'a, E = SyncEffect> +pub trait SequenceScope<'ctx, E = SyncEffect> where E: Effect<'ctx> + Effect<'ctx, Status>, { - fn next(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E, Status>; + fn next<'a>(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E, Status> where 'ctx: 'a; } #[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Debug)] @@ -37,6 +38,8 @@ pub enum Status { Continue, } +hkt!((any_t): for<'a, 'ctx> pub KnownHkt => Known); + #[derive(Default)] pub struct Known { pub len: (usize, Option<usize>), @@ -46,8 +49,8 @@ pub struct Hint { pub len: (usize, Option<usize>), } -impl<'a, 'ctx: 'a, E: Effect<'ctx>> HintMeta<'a, 'ctx> for dyn Sequence<'a, 'ctx, E> + '_ { - type Known = Known; +impl<'a, 'ctx: 'a, E: Effect<'ctx>> HintMeta<'ctx> for dyn Sequence<'ctx, E> + '_ { + type KnownHkt = KnownHkt<'ctx>; type Hint = Hint; } diff --git a/src/protocol/visitor/tagged.rs b/src/protocol/visitor/tagged.rs index 0258ac9..1f33ca7 100644 --- a/src/protocol/visitor/tagged.rs +++ b/src/protocol/visitor/tagged.rs @@ -1,38 +1,41 @@ use crate::{ nameable, - protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect, Visitor}, + protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect, Visitor, any_t}, symbol::Symbol, + hkt::hkt, }; -pub trait Tagged<'a, 'ctx: 'a, E: Effect<'ctx> = SyncEffect> { - fn visit( +pub trait Tagged<'ctx, E: Effect<'ctx> = SyncEffect> { + fn visit<'a>( &'a mut self, - scope: &'a mut dyn TaggedScope<'a, 'ctx, E>, - ) -> ControlFlowFor<'a, 'ctx, E>; + scope: &'a mut dyn TaggedScope<'ctx, E>, + ) -> ControlFlowFor<'a, 'ctx, E> where 'ctx: 'a; } nameable! { - pub struct Name['a, 'ctx: 'a, E]; + pub struct Name['a, 'ctx, E]; - impl [E] for dyn Tagged<'a, 'ctx, E> + 'a where { + impl [E] for dyn Tagged<'ctx, E> + 'a where { E: Effect<'ctx>, 'ctx: 'a } - impl [E] where dyn Tagged<'a, 'ctx, E> + 'a { + impl [E] where dyn Tagged<'ctx, E> + 'a { E: Effect<'ctx>, 'ctx: 'a } } -pub trait TaggedScope<'a, 'ctx: 'a, E: Effect<'ctx> = SyncEffect> { +pub trait TaggedScope<'ctx, E: Effect<'ctx> = SyncEffect> { fn kind(&mut self) -> Symbol; - fn tag(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E>; + fn tag<'a>(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E> where 'ctx: 'a; - fn value(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E>; + fn value<'a>(&'a mut self, visitor: Visitor<'a, 'ctx, E>) -> ControlFlowFor<'a, 'ctx, E> where 'ctx: 'a; } +hkt!((any_t): for<'a, 'ctx> pub KnownHkt => Known); + pub struct Known { pub kind_available: Option<bool>, } @@ -41,8 +44,8 @@ pub struct Hint { pub kind: Option<Symbol>, } -impl<'a, 'ctx: 'a, Return> HintMeta<'a, 'ctx> for dyn Tagged<'a, 'ctx, Return> + 'a { - type Known = Known; +impl<'a, 'ctx: 'a, Return> HintMeta<'ctx> for dyn Tagged<'ctx, Return> + 'a { + type KnownHkt = KnownHkt<'ctx>; type Hint = Hint; } diff --git a/src/protocol/visitor/value.rs b/src/protocol/visitor/value.rs index 320d1ae..20438bb 100644 --- a/src/protocol/visitor/value.rs +++ b/src/protocol/visitor/value.rs @@ -5,13 +5,14 @@ use crate::{ any::{TypeName, TypeNameable}, nameable, - protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect}, + protocol::{walker::HintMeta, ControlFlowFor, Effect, SyncEffect, any_t}, + hkt::hkt, }; /// Trait object for the [`Value`] protocol. /// /// Types implementing the [`Value`] protocol will implement this trait. -pub trait Value<'a, 'ctx: 'a, T, E: Effect<'ctx> = SyncEffect> { +pub trait Value<'ctx, T, E: Effect<'ctx> = SyncEffect> { /// Visit a value of type `T`. /// /// Use this to give a value to a visitor. Its expected that a walker @@ -21,26 +22,30 @@ pub trait Value<'a, 'ctx: 'a, T, E: Effect<'ctx> = SyncEffect> { /// If a [`ControlFlow::Break`] is returned then the walker /// should stop walking as soon as possible as there has likely been /// and error. - fn visit(&'a mut self, value: T) -> ControlFlowFor<'a, 'ctx, E>; + fn visit<'a>(&'a mut self, value: T) -> ControlFlowFor<'a, 'ctx, E> where 'ctx: 'a; } nameable! { - pub struct Name['a, 'ctx: 'a, T, E]; + pub struct Name['a, 'ctx, T, E]; - impl [T::Name, E] for dyn Value<'a, 'ctx, T, E> + 'a where { + impl [T::Name, E] for dyn Value<'ctx, T, E> + 'a where { T: TypeNameable<'a, 'ctx> + ?Sized, E: Effect<'ctx>, + 'ctx: 'a, } - impl [T, E] where dyn Value<'a, 'ctx, T::Nameable, E> + 'a { + impl [T, E] where dyn Value<'ctx, T::Nameable, E> + 'a { T: TypeName<'a, 'ctx> + ?Sized, E: Effect<'ctx>, + 'ctx: 'a, } } +hkt!((any_t): for<'a, 'ctx> pub KnownHkt => ()); + // This enrolls the Value protocol into the walker hint system. -impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> HintMeta<'a, 'ctx> for dyn Value<'a, 'ctx, T, E> + 'a { - type Known = (); +impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> HintMeta<'ctx> for dyn Value<'ctx, T, E> + 'a { + type KnownHkt = KnownHkt<'ctx>; type Hint = (); } @@ -63,21 +68,21 @@ mod test { fn visit() { struct Visitor(Option<i32>); - impl Value<'_, OwnedStatic<i32>> for Visitor { - fn visit( - &mut self, + impl<'ctx> Value<'ctx, OwnedStatic<i32>> for Visitor { + fn visit<'a>( + &'a mut self, OwnedStatic(value): OwnedStatic<i32>, - ) -> core::ops::ControlFlow<()> { + ) -> core::ops::ControlFlow<()> where 'ctx: 'a { self.0 = Some(value); ControlFlow::Continue(()) } } - impl Value<'_, BorrowedStatic<'_, i32>> for Visitor { - fn visit( - &mut self, - BorrowedStatic(value): BorrowedStatic<'_, i32>, - ) -> core::ops::ControlFlow<()> { + impl<'ctx> Value<'ctx, BorrowedStatic<'ctx, i32>> for Visitor { + fn visit<'a>( + &'a mut self, + BorrowedStatic(value): BorrowedStatic<'ctx, i32>, + ) -> core::ops::ControlFlow<()> where 'ctx: 'a { self.0 = Some(*value); ControlFlow::Continue(()) } @@ -85,9 +90,9 @@ mod test { any_trait! { impl['a, 'ctx] Visitor = [ - dyn Value<'a, OwnedStatic<i32>> + 'a, - dyn Value<'a, BorrowedStatic<'ctx, i32>> + 'a, - ]; + dyn Value<'ctx, OwnedStatic<i32>> + 'a, + dyn Value<'ctx, BorrowedStatic<'ctx, i32>> + 'a, + ] } let mut v = Visitor(None); @@ -112,11 +117,11 @@ mod test { fn visit_borrowed() { struct Visitor<'ctx>(Option<&'ctx mut String>); - impl<'a, 'ctx> Value<'a, BorrowedMutStatic<'ctx, String>> for Visitor<'ctx> { - fn visit( + impl<'ctx> Value<'ctx, BorrowedMutStatic<'ctx, String>> for Visitor<'ctx> { + fn visit<'a>( &'a mut self, BorrowedMutStatic(value): BorrowedMutStatic<'ctx, String>, - ) -> ControlFlow<()> { + ) -> ControlFlow<()> where 'ctx: 'a { self.0 = Some(value); ControlFlow::Continue(()) } @@ -124,8 +129,8 @@ mod test { any_trait! { impl['a, 'ctx] Visitor<'ctx> = [ - dyn Value<'a, BorrowedMutStatic<'ctx, String>> + 'a, - ]; + dyn Value<'ctx, BorrowedMutStatic<'ctx, String>> + 'a, + ] } let mut v = Visitor(None); @@ -145,11 +150,11 @@ mod test { fn visit_borrowed_unsized() { struct Visitor<'ctx>(Option<&'ctx str>); - impl<'a, 'ctx> Value<'a, BorrowedStatic<'ctx, str>> for Visitor<'ctx> { - fn visit( + impl<'ctx> Value<'ctx, BorrowedStatic<'ctx, str>> for Visitor<'ctx> { + fn visit<'a>( &'a mut self, BorrowedStatic(value): BorrowedStatic<'ctx, str>, - ) -> ControlFlow<()> { + ) -> ControlFlow<()> where 'ctx: 'a { self.0 = Some(value); ControlFlow::Continue(()) } @@ -157,8 +162,8 @@ mod test { any_trait! { impl['a, 'ctx] Visitor<'ctx> = [ - dyn Value<'a, BorrowedStatic<'ctx, str>> + 'a, - ]; + dyn Value<'ctx, BorrowedStatic<'ctx, str>> + 'a, + ] } let mut v = Visitor(None); @@ -166,7 +171,7 @@ mod test { let y = String::from("abc"); let object: &mut dyn AnyTrait<'_> = &mut v; object - .upcast_mut::<dyn Value<'_, BorrowedStatic<'_, str>>>() + .upcast_mut::<dyn Value<'_, BorrowedStatic<'_, str>> + '_>() .unwrap() .visit(BorrowedStatic(&y)); diff --git a/src/protocol/walker/hint.rs b/src/protocol/walker/hint.rs index 06c8794..ce73b7e 100644 --- a/src/protocol/walker/hint.rs +++ b/src/protocol/walker/hint.rs @@ -7,42 +7,42 @@ use crate::{ any::{TypeName, TypeNameable}, nameable, - protocol::{ControlFlowFor, Effect, SyncEffect, Visitor}, + protocol::{ControlFlowFor, Effect, SyncEffect, Visitor, any_t}, }; /// Meta information for the hint. /// /// This gives the visitor more information to work from when selecting a hint. -pub trait HintMeta<'a, 'ctx: 'a> { +pub trait HintMeta<'ctx> { /// Information known by the walker. /// /// This should be information easy to get without changing the state of the walker /// in an irreversible way. - type Known; + type KnownHkt: any_t::Hkt<'ctx>; /// Extra information the visitor can give to the walker about what it is expecting. type Hint; } /// Object implementing the [`Hint`] protocol. -pub trait Hint<'ctx, Protocol: ?Sized + for<'a> HintMeta<'a, 'ctx>, E = SyncEffect> +pub trait Hint<'ctx, Protocol: ?Sized + HintMeta<'ctx>, E = SyncEffect> where - E: Effect<'ctx> + Effect<'ctx, <Protocol as HintMeta<'a, 'ctx>>::Known> + E: Effect<'ctx> + for<'a> Effect<'ctx, <<Protocol as HintMeta<'ctx>>::KnownHkt as any_t::ForLt<'a, 'ctx, crate::hkt::Bound<'a, 'ctx>>>::T> { /// Hint to the walker to use the `P` protocol. /// /// This should only be called once per [`RequestHint`]. fn hint<'a>( &'a mut self, - visitor: &'a mut Visitor<'a, 'ctx, E>, - hint: <Protocol as HintMeta<'a, 'ctx>>::Hint, + visitor: Visitor<'a, 'ctx, E>, + hint: <Protocol as HintMeta<'ctx>>::Hint, ) -> ControlFlowFor<'a, 'ctx, E>; /// Ask the walker for information about it's support of the protocol. fn known<'a>( &'a mut self, - hint: &'a <Protocol as HintMeta<'a, 'ctx>>::Hint, - ) -> ControlFlowFor<'a, 'ctx, E, <Protocol as HintMeta<'a, 'ctx>>::Known> + hint: &'a <Protocol as HintMeta<'ctx>>::Hint, + ) -> ControlFlowFor<'a, 'ctx, E, any_t::T<'a, 'ctx, <Protocol as HintMeta<'ctx>>::KnownHkt>> where 'ctx: 'a; } @@ -68,6 +68,7 @@ mod test { use core::ops::ControlFlow; use crate::any::{LtTypeId, TypeNameable}; + use crate::hkt::hkt; use super::*; @@ -84,16 +85,16 @@ mod test { impl<'ctx, X> Hint<'ctx, Y> for X { fn hint<'a>( &'a mut self, - visitor: &'a mut Visitor<'a, 'ctx>, - hint: <Y as HintMeta<'ctx>>::Hint<'a>, + visitor: Visitor<'a, 'ctx, SyncEffect>, + hint: <Y as HintMeta<'ctx>>::Hint, ) -> ControlFlow<()> { todo!() } fn known<'a>( &'a mut self, - hint: &'a <Y as HintMeta<'ctx>>::Hint<'a>, - ) -> ControlFlow<(), <Y as HintMeta<'ctx>>::Known<'a>> + hint: &'a <Y as HintMeta<'ctx>>::Hint, + ) -> ControlFlow<(), any_t::T<'a, 'ctx, <Y as HintMeta<'ctx>>::KnownHkt>> where 'ctx: 'a, { @@ -101,10 +102,12 @@ mod test { } } + hkt!((any_t): for<'a, 'ctx> KnownHkt => ()); + impl<'ctx> HintMeta<'ctx> for Y { - type Known<'a> = () where 'ctx: 'a; + type KnownHkt = KnownHkt<'ctx>; - type Hint<'a> = () where 'ctx: 'a; + type Hint = (); } let x = X; @@ -115,7 +118,5 @@ mod test { } id(y); - - // todo!(); } } |