+struct

+- name

+- type_id

+- fields

+ - name

+ - index

+ - type_id

+

+ name: &'static str,

+ name: core::any::type_name::<T>(),

+impl<'lt> core::fmt::Display for LtTypeId<'lt> {

+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

+ core::fmt::Display::fmt(self.name, f)

+ }

+}

+

+ impl[$a:lifetime, $lt:lifetime $($generic:tt)*] $name:ty = [$($protocol:ty),* $(,)?] $(else $fallback:path)? $(where $($bound:tt)*)?

+ _ => {

+ $($fallback(id);)?

+ ::core::option::Option::None

+ }

+ _ => {

+ $($fallback(id);)?

+ ::core::option::Option::None

+ }

+ type Builder<E: Effect<'ctx>>: Builder<

+ 'ctx,

+ Seed = Self::Seed,

+ Error = Self::Error,

+ Value = Self,

+ Effect = E,

+ >;

+

+#[cfg(feature = "std")]

+pub mod debug;

+// pub mod option;

+pub mod tag_name;

+ dyn Value<'a, 'ctx, OwnedStatic<bool>, Effect = E> + 'a,

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<bool>> for Builder<E> {

+ type Effect = E;

+

+impl<'ctx, T> crate::BuilderTypes<'ctx> for Option<T>

+impl<'ctx, B, E: Effect<'ctx>> crate::BuilderTypes<'ctx> for Builder<'ctx, B, E>

+ ] where B: crate::Builder<'ctx, Effect = E>, E: Effect<'ctx>,

+ E::wrap(core::future::ready(match value {

+ E::wrap(core::future::ready(match value {

+ E::wrap(core::future::ready(match value {

+ E::wrap(core::future::ready(match value {

+ E::wrap(core::future::ready(match value {

+

+use core::{any::TypeId, marker::PhantomData, ops::ControlFlow};

+

+use crate::{

+ any::{static_wrapper::OwnedStatic, LtTypeId},

+ any_trait,

+ effect::{Effect, Future},

+ protocol::{visitor::{

+ tag::{Dyn, Tag},

+ value::Value, request_hint::RequestHint,

+ }, self},

+ DynWalker,

+};

+

+pub struct Walker<E>(usize, PhantomData<fn() -> E>);

+

+any_trait! {

+ impl['a, 'ctx, E] Walker<E> = [

+ dyn RequestHint<'ctx, Effect = E> + 'a,

+ dyn Tag<'ctx, Dyn, Effect = E> + 'a,

+ dyn Value<'a, 'ctx, OwnedStatic<&'static str>, Effect = E> + 'a,

+ dyn Value<'a, 'ctx, OwnedStatic<TypeId>, Effect = E> + 'a,

+ ] else fallback where E: Effect<'ctx>

+}

+

+fn fallback(id: LtTypeId<'_>) {

+ println!("Unknown trait: {}", id);

+}

+

+impl<'ctx, E: Effect<'ctx>> Walker<E> {

+ pub fn new() -> Self {

+ Self(0, PhantomData)

+ }

+

+ fn tab(&self) {

+ for _ in 0..self.0 {

+ print!(" ");

+ }

+ }

+}

+

+impl<'ctx, E: Effect<'ctx>> RequestHint<'ctx> for Walker<E> {

+ type Effect = E;

+

+ fn request_hint<'a>(

+ &'a mut self,

+ _walker: crate::protocol::Walker<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>

+ where

+ Self: 'a

+ {

+ self.tab();

+ println!("Visit request hint (no hint given)");

+ E::wrap(async { ControlFlow::Continue(()) })

+ }

+}

+

+impl<'ctx, E: Effect<'ctx>> Tag<'ctx, Dyn> for Walker<E> {

+ type Effect = E;

+

+ fn visit<'a>(

+ &'a mut self,

+ kind: Dyn,

+ walker: &'a mut dyn DynWalker<'ctx, Effect = Self::Effect>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), protocol::visitor::tag::Status>, Self::Effect>

+ where

+ Self: 'a,

+ {

+ self.tab();

+ println!("Visit tag: {}", kind.0);

+

+ E::wrap(async {

+ self.0 += 1;

+ let result = walker.walk(self).await;

+ self.0 -= 1;

+ match result {

+ ControlFlow::Continue(()) => ControlFlow::Continue(protocol::visitor::tag::Status::Walked),

+ ControlFlow::Break(()) => ControlFlow::Break(()),

+ }

+ })

+ }

+}

+

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<&'static str>> for Walker<E> {

+ type Effect = E;

+

+ fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<&'static str>) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect> where Self: 'a {

+ self.tab();

+ println!("Visit static str: {:?}", value);

+ E::wrap(async { ControlFlow::Continue(()) })

+ }

+}

+

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<TypeId>> for Walker<E> {

+ type Effect = E;

+

+ fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<TypeId>) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect> where Self: 'a {

+ self.tab();

+ println!("Visit type ID: {:?}", value);

+ E::wrap(async { ControlFlow::Continue(()) })

+ }

+}

+use core::ops::ControlFlow;

+

+use effect::{Effect, Future};

+use protocol::Visitor;

+use symbol::Symbol;

+pub mod never {

+ mod sealed {

+ pub trait Extract {

+ type T;

+ }

+

+ impl<T> Extract for fn() -> T {

+ type T = T;

+ }

+ }

+

+ #[doc(hidden)]

+ pub type Never = <fn() -> ! as sealed::Extract>::T;

+}

+

+pub const TAG_TYPE_NAME: Symbol = Symbol::new("Type Name");

+pub const TAG_TYPE_ID: Symbol = Symbol::new("Type ID");

+pub const TAG_TYPE_SIZE: Symbol = Symbol::new("Type Size");

+pub const TAG_FIELD_NAMES: Symbol = Symbol::new("Field Names");

+

+#[derive(Debug)]

+pub enum StructWalkError {

+ Tag(Symbol, &'static str),

+}

+

+macro_rules! Walk {

+ impl<'ctx> $crate::Walk<'ctx> for &'ctx $name {

+ type Walker<E: $crate::effect::Effect<'ctx>> = Walker<'ctx, E>;

+ fn into_walker<E: $crate::effect::Effect<'ctx>>(self) -> Self::Walker<E> {

+ Walker {

+ value: self,

+ _marker: ::core::marker::PhantomData,

+ impl<'ctx> $crate::WalkerTypes<'ctx> for &'ctx $name {

+ type Error = $crate::StructWalkError;

+ type Output = ();

+ pub struct Walker<'ctx, E> {

+ value: &'ctx $name,

+ _marker: ::core::marker::PhantomData<fn() -> E>,

+ impl<'ctx, E> $crate::WalkerTypes<'ctx> for Walker<'ctx, E> {

+ type Error = $crate::StructWalkError;

+ type Output = ();

+ impl<'ctx, E: $crate::effect::Effect<'ctx>> $crate::Walker<'ctx> for Walker<'ctx, E> {

+ type Effect = E;

+ fn walk<'a>(

+ mut self,

+ visitor: $crate::protocol::Visitor<'a, 'ctx>,

+ ) -> $crate::effect::Future<'a, 'ctx, Result<Self::Output, Self::Error>, Self::Effect>

+ where

+ Self: 'a

+ {

+ E::wrap(async move {

+ // We should check if the visitor wants something specific.

+ if let Some(object) = visitor.upcast_mut::<dyn $crate::protocol::visitor::request_hint::RequestHint<'ctx, Effect = E> + '_>() {

+ // Allow the visitor to give a hint if it wants.

+ match object.request_hint(&mut self).await {

+ ::core::ops::ControlFlow::Continue(()) => {

+ // The visitor wants the walker to continue to it's normal

+ // walking.

+ },

+ ::core::ops::ControlFlow::Break(()) => {

+ // The visitor is done (either because of an error or because

+ // it already used a hint).

+ return Ok(());

+ },

+ }

+ }

+ // Follow the standard set of protocols for a struct.

+ // - Tagged: struct name

+ // - Tagged: struct type

+ // - Tagged: struct field names

+ // - Sequence: the fields

+ if let Ok((result, flow)) =

+ $crate::try_visit_tag::<{ $crate::TAG_TYPE_NAME.to_int() }, E, _>(

+ visitor,

+ $crate::walkers::core::tag::NameWalker::new(stringify!($name))

+ ).await

+ {

+ match result {

+ Ok(()) => {},

+ Err($crate::DynWalkerError::Walker($crate::walkers::core::tag::MissingProtocol(msg))) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_NAME, msg))

+ }

+ Err($crate::DynWalkerError::NeverWalked(_)) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_NAME, "visitor didn't walk walker"))

+ },

+ Err($crate::DynWalkerError::WalkNeverFinished) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_NAME, "walk didn't finish"))

+ },

+ }

+

+ if let ::core::ops::ControlFlow::Break(()) = flow {

+ return Ok(());

+ }

+ }

+

+ if let Ok((result, flow)) =

+ $crate::try_visit_tag::<{ $crate::TAG_TYPE_ID.to_int() }, E, _>(

+ visitor,

+ $crate::walkers::core::tag::TypeIdWalker::new::<$name>()

+ ).await

+ {

+ match result {

+ Ok(()) => {},

+ Err($crate::DynWalkerError::Walker($crate::walkers::core::tag::MissingProtocol(msg))) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_ID, msg))

+ }

+ Err($crate::DynWalkerError::NeverWalked(_)) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_ID, "visitor didn't walk walker"))

+ },

+ Err($crate::DynWalkerError::WalkNeverFinished) => {

+ return Err($crate::StructWalkError::Tag($crate::TAG_TYPE_ID, "walk didn't finish"))

+ },

+ }

+

+ if let ::core::ops::ControlFlow::Break(()) = flow {

+ return Ok(());

+ }

+ }

+

+ todo!()

+ })

+

+ $crate::any::any_trait! {

+ impl['a, 'ctx, E] Walker<'ctx, E> = [

+ // dyn Hint<'a, 'ctx, OwnedStatic<bool>, E> + 'a,

+ ] where E: $crate::effect::Effect<'ctx>

+ }

+

+

+pub fn try_visit_tag<

+ 'a,

+ 'ctx,

+ const SYMBOL: u64,

+ E: Effect<'ctx>,

+ W: Walker<'ctx, Effect = E> + 'a,

+>(

+ visitor: Visitor<'a, 'ctx>,

+ walker: W,

+) -> Future<

+ 'a,

+ 'ctx,

+ Result<

+ (

+ Result<W::Output, DynWalkerError<'ctx, W>>,

+ ControlFlow<(), protocol::visitor::tag::Status>,

+ ),

+ W,

+ >,

+ E,

+> {

+ E::wrap(async {

+ if let Some(object) = visitor.upcast_mut::<

+ dyn protocol::visitor::tag::Tag<

+ 'ctx,

+ protocol::visitor::tag::Const<SYMBOL>,

+ Effect = E

+ > + '_

+ >() {

+ let mut name_walker = DynWalkerAdapter::new(walker);

+ let flow = object.visit(protocol::visitor::tag::Const, &mut name_walker).await;

+ Ok((name_walker.finish(), match flow {

+ ControlFlow::Continue(()) => ControlFlow::Continue(protocol::visitor::tag::Status::Walked),

+ ControlFlow::Break(()) => ControlFlow::Break(()),

+ }))

+ } else if let Some(object) = visitor.upcast_mut::<

+ dyn protocol::visitor::tag::Tag<

+ 'ctx,

+ protocol::visitor::tag::Dyn,

+ Effect = E

+ > + '_

+ >() {

+ let mut name_walker = DynWalkerAdapter::new(walker);

+ let flow = object.visit(protocol::visitor::tag::Dyn(Symbol::from_int(SYMBOL)), &mut name_walker).await;

+ Ok((name_walker.finish(), flow))

+ } else {

+ Err(walker)

+ }

+ })

+}

+

+#[cfg(test)]

+mod test {

+ use crate::effect::{BlockOn, Blocking, Spin};

+

+ use super::*;

+ use macro_rules_attribute::derive;

+

+ #[derive(Walk!)]

+ struct Demo {

+ a: bool,

+ b: bool,

+ }

+

+ #[test]

+ fn demo() {

+ let value = Demo { a: true, b: false };

+

+ let walker = value.into_walker::<Blocking>();

+ let mut visitor = builders::debug::Walker::<Blocking>::new();

+

+ dbg!(Spin::block_on(walker.walk(&mut visitor)));

+

+ todo!();

+ }

+}

+pub mod tag;

+pub trait RequestHint<'ctx> {

+ type Effect: Effect<'ctx>;

+

+ fn request_hint<'a>(

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>

+ where

+ Self: 'a;

+ impl [E] for dyn RequestHint<'ctx, Effect = E> + 'a where {

+pub trait Sequence<'ctx> {

+ type Effect: Effect<'ctx>;

+

+ scope: &'a mut dyn SequenceScope<'ctx, Self::Effect>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>;

+ impl [E] for dyn Sequence<'ctx, Effect = E> + 'a where {

+ impl [E] where dyn Sequence<'ctx, Effect = E> + 'a {

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> HintMeta<'ctx> for dyn Sequence<'ctx, Effect = E> + '_ {

+use core::ops::ControlFlow;

+

+use crate::{

+ any::{TypeName, TypeNameable},

+ effect::{Effect, Future},

+ higher_ranked_type,

+ hkt::AnySend,

+ nameable,

+ protocol::{walker::hint::HintMeta, Visitor, Walker},

+ symbol::Symbol,

+ DynWalker,

+};

+

+pub trait Kind: 'static {

+ type Status: Send;

+

+ fn symbol(&self) -> Symbol;

+}

+

+pub struct Const<const SYMBOL: u64>;

+pub struct Dyn(pub Symbol);

+

+impl<const SYMBOL: u64> Kind for Const<SYMBOL> {

+ type Status = ();

+

+ fn symbol(&self) -> Symbol {

+ Symbol::from_int(SYMBOL)

+ }

+}

+

+impl Kind for Dyn {

+ type Status = Status;

+

+ fn symbol(&self) -> Symbol {

+ self.0

+ }

+}

+

+pub trait Tag<'ctx, K: Kind> {

+ type Effect: Effect<'ctx>;

+

+ fn visit<'a>(

+ &'a mut self,

+ kind: K,

+ walker: &'a mut dyn DynWalker<'ctx, Effect = Self::Effect>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), K::Status>, Self::Effect>

+ where

+ Self: 'a;

+}

+

+#[must_use]

+pub enum Status {

+ Walked,

+ Skiped,

+}

+

+nameable! {

+ pub struct Name['a, 'ctx, K, E];

+

+ impl [K, E] for dyn Tag<'ctx, K, Effect = E> + 'a where {

+ K: Kind,

+ E: Effect<'ctx>,

+ 'ctx: 'a

+ }

+

+ impl [K, E] where dyn Tag<'ctx, K, Effect = E> + 'a {

+ K: Kind,

+ E: Effect<'ctx>,

+ 'ctx: 'a

+ }

+}

+

+higher_ranked_type! {

+ pub type KnownHkt['ctx]: (AnySend) = for<'lt> Known

+}

+

+pub struct Known {

+ pub kind_available: Option<bool>,

+}

+

+pub struct Hint<K> {

+ pub kind: Option<K>,

+}

+

+impl<'a, 'ctx: 'a, K, E> HintMeta<'ctx> for dyn Tag<'ctx, K, Effect = E> + 'a {

+ type Known = KnownHkt<'ctx>;

+

+ type Hint = Hint<K>;

+}

+pub trait Value<'a, 'ctx: 'a, T> {

+ type Effect: Effect<'ctx>;

+

+ fn visit(&'a mut self, value: T) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>

+ where

+ Self: 'a;

+ impl [T::Name, E] for dyn Value<'a, 'ctx, T, Effect = E> + 'a where {

+ impl [T, E] where dyn Value<'a, 'ctx, T::Nameable, Effect = E> + 'a {

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> HintMeta<'ctx> for dyn Value<'a, 'ctx, T, Effect = E> + 'a {

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, OwnedStatic<i32>> for Visitor<E>

+ type Effect = E;

+

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedStatic<'ctx, i32>> for Visitor<E>

+ type Effect = E;

+

+ dyn Value<'a, 'ctx, OwnedStatic<i32>, Effect = E> + 'a,

+ dyn Value<'a, 'ctx, BorrowedStatic<'ctx, i32>, Effect = E> + 'a,

+ .upcast_mut::<dyn Value<'_, '_, OwnedStatic<i32>, Effect = Blocking>>()

+ .upcast_mut::<dyn Value<'_, '_, BorrowedStatic<'_, i32>, Effect = Blocking>>()

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedMutStatic<'ctx, String>> for Visitor<'ctx, E>

+ type Effect = E;

+

+ dyn Value<'a, 'ctx, BorrowedMutStatic<'ctx, String>, Effect = E> + 'a,

+ .upcast_mut::<dyn Value<'_, '_, _, Effect = Blocking>>()

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedStatic<'ctx, str>> for Visitor<'ctx, E>

+ type Effect = E;

+

+ dyn Value<'a, 'ctx, BorrowedStatic<'ctx, str>, Effect = E> + 'a,

+ .upcast_mut::<dyn Value<'_, '_, BorrowedStatic<'_, str>, Effect = Blocking> + '_>()

+pub trait Hint<'ctx, Protocol: ?Sized + HintMeta<'ctx>> {

+ type Effect: Effect<'ctx>;

+

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>;

+ ) -> Future<'a, 'ctx, ControlFlow<(), Known<'a, 'ctx, Protocol>>, Self::Effect>;

+ impl [Protocol::Name, E] for dyn Hint<'ctx, Protocol, Effect = E> + 'a where {

+ impl [Protocol, E] where dyn Hint<'ctx, Protocol::Nameable, Effect = E> + 'a {

+ impl<'ctx> Hint<'ctx, Y> for X<'ctx> {

+ type Effect = Blocking;

+

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect> {

+ ) -> Future<'a, 'ctx, ControlFlow<(), Known<'a, 'ctx, Y>>, Self::Effect> {

+ Self::Effect::wrap(async { ControlFlow::Continue(&mut *self.0) })

+ let y: &mut dyn Hint<'_, Y, Effect = Blocking> = &mut x;

+ #[inline]

+ #[inline]

+ #[inline]

+ #[inline]

+use core::ops::ControlFlow;

+

+ type Walker<E: Effect<'ctx>>: Walker<

+ 'ctx,

+ Error = Self::Error,

+ Output = Self::Output,

+ Effect = E,

+ >;

+

+pub trait DynWalker<'ctx>: Send {

+ type Effect: Effect<'ctx>;

+

+ fn walk<'a>(

+ &'a mut self,

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>

+ where

+ Self: 'a;

+}

+

+enum DynWalkerState<'ctx, W: WalkerTypes<'ctx>> {

+ Walking,

+ Pending(W),

+ Done(Result<W::Output, W::Error>),

+}

+

+pub enum DynWalkerError<'ctx, W: WalkerTypes<'ctx>> {

+ NeverWalked(W),

+

+ /// This can only happen if a panic happens furing the walk and is then caught before calling

+ /// finish..

+ WalkNeverFinished,

+

+ Walker(W::Error),

+}

+

+pub struct DynWalkerAdapter<'ctx, W: WalkerTypes<'ctx>> {

+ state: DynWalkerState<'ctx, W>,

+}

+

+impl<'ctx, W: WalkerTypes<'ctx>> DynWalkerAdapter<'ctx, W> {

+ pub fn new(walker: W) -> Self {

+ Self {

+ state: DynWalkerState::Pending(walker),

+ }

+ }

+

+ pub fn finish(self) -> Result<W::Output, DynWalkerError<'ctx, W>> {

+ match self.state {

+ DynWalkerState::Walking => Err(DynWalkerError::WalkNeverFinished),

+ DynWalkerState::Pending(walker) => Err(DynWalkerError::NeverWalked(walker)),

+ DynWalkerState::Done(result) => result.map_err(DynWalkerError::Walker),

+ }

+ }

+}

+

+impl<'ctx, W: Walker<'ctx>> DynWalker<'ctx> for DynWalkerAdapter<'ctx, W> {

+ type Effect = W::Effect;

+

+ fn walk<'a>(

+ &'a mut self,

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, Self::Effect>

+ where

+ Self: 'a,

+ {

+ Self::Effect::wrap(async {

+ if let DynWalkerState::Pending(walker) =

+ core::mem::replace(&mut self.state, DynWalkerState::Walking)

+ {

+ // Walk the walker.

+ self.state = DynWalkerState::Done(walker.walk(visitor).await);

+ } else {

+ // Can't do anything if the walker has already been walked.

+ }

+ ControlFlow::Continue(())

+ })

+ }

+}

+

+pub mod tag;

+ visitor.upcast_mut::<dyn Value<'_, 'ctx, OwnedStatic<bool>, Effect = E> + '_>()

+use core::{any::TypeId, marker::PhantomData};

+

+use crate::{

+ any::static_wrapper::OwnedStatic, effect::Effect, protocol::visitor::value::Value, WalkerTypes,

+};

+

+pub struct NameWalker<E>(&'static str, PhantomData<fn() -> E>);

+

+impl<E> NameWalker<E> {

+ pub fn new(name: &'static str) -> Self {

+ Self(name, PhantomData)

+ }

+}

+

+pub struct MissingProtocol(pub &'static str);

+

+impl<'ctx, E> WalkerTypes<'ctx> for NameWalker<E> {

+ type Error = MissingProtocol;

+

+ type Output = ();

+}

+

+impl<'ctx, E: Effect<'ctx>> crate::Walker<'ctx> for NameWalker<E> {

+ type Effect = E;

+

+ fn walk<'a>(

+ self,

+ visitor: crate::protocol::Visitor<'a, 'ctx>,

+ ) -> crate::effect::Future<'a, 'ctx, Result<Self::Output, Self::Error>, Self::Effect>

+ where

+ Self: 'a,

+ {

+ E::wrap(async {

+ // We don't need to request a hint because we always just visit a static string.

+ if let Some(object) = visitor

+ .upcast_mut::<dyn Value<'_, 'ctx, OwnedStatic<&'static str>, Effect = E> + '_>()

+ {

+ // Visit with the name.

+ object.visit(OwnedStatic(self.0)).await;

+

+ Ok(())

+ } else {

+ Err(MissingProtocol(

+ "visitor missing protocol Value<&'static str>",

+ ))

+ }

+ })

+ }

+}

+

+pub struct TypeIdWalker<E>(TypeId, PhantomData<fn() -> E>);

+

+impl<E> TypeIdWalker<E> {

+ pub fn new<T: 'static>() -> Self {

+ Self(TypeId::of::<T>(), PhantomData)

+ }

+}

+

+impl<'ctx, E> WalkerTypes<'ctx> for TypeIdWalker<E> {

+ type Error = MissingProtocol;

+

+ type Output = ();

+}

+

+impl<'ctx, E: Effect<'ctx>> crate::Walker<'ctx> for TypeIdWalker<E> {

+ type Effect = E;

+

+ fn walk<'a>(

+ self,

+ visitor: crate::protocol::Visitor<'a, 'ctx>,

+ ) -> crate::effect::Future<'a, 'ctx, Result<Self::Output, Self::Error>, Self::Effect>

+ where

+ Self: 'a,

+ {

+ E::wrap(async move {

+ // We don't need to request a hint because we always just visit a static string.

+ if let Some(object) =

+ visitor.upcast_mut::<dyn Value<'_, 'ctx, OwnedStatic<TypeId>, Effect = E> + '_>()

+ {

+ // Visit with the name.

+ object.visit(OwnedStatic(self.0)).await;

+

+ Ok(())

+ } else {

+ Err(MissingProtocol("visitor missing protocol Value<TypeId>"))

+ }

+ })

+ }

+}

+ builders::core::option::IgnoreMissing,

+ transform, Build, Builder, Walk, Walker, WalkerTypes,

+ let x = Spin::block_on(transform::<<bool as Build>::Builder<_>, _, Blocking>(

+ (),

+ hook,

+ ));

+ }

+impl<'a, 'b, 'ctx: 'a + 'b, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<bool>, E>

+ for VisitorHook<'b, 'ctx, E>

+{