+mod erased;

+mod mut_any_unsized;

+mod ref_any_unsized;

+pub mod type_name;

+use crate::hkt::Marker;

+pub use mut_any_unsized::*;

+pub use ref_any_unsized::*;

+pub trait AnyTrait<'ctx> {

+ fn upcast_by_id<'a, 'lt: 'a>(

+ &'a self,

+ id: WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<RefAnyUnsized<'a, 'lt, 'ctx>>

+ where

+ 'ctx: 'lt,

+ let _id = id;

+ None

+ fn upcast_by_id_mut<'a, 'lt: 'a>(

+ &'a mut self,

+ id: WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<MutAnyUnsized<'a, 'lt, 'ctx>>

+ where

+ 'ctx: 'lt,

+ let _id = id;

+ None

+}

+impl<'lt, 'ctx: 'lt> dyn AnyTrait<'ctx> + 'lt {

+ #[track_caller]

+ pub fn upcast<'a, T: ?Sized + type_name::WithLt<'lt, 'ctx>>(&'a self) -> Option<&'a T> {

+ self.upcast_by_id(WithLtTypeId::of::<T>())

+ .map(|value| match value.downcast::<T>() {

+ Ok(value) => value,

+ Err(_) => panic!("wrong type returned by upcast_by_id"),

+ })

+ #[track_caller]

+ pub fn upcast_mut<'a, T: ?Sized + type_name::WithLt<'lt, 'ctx>>(

+ &'a mut self,

+ ) -> Option<&'a mut T> {

+ self.upcast_by_id_mut(WithLtTypeId::of::<T>())

+ .map(|value| match value.downcast::<T>() {

+ Ok(value) => value,

+ Err(_) => panic!("wrong type returned by upcast_by_id_mut"),

+ })

+const _: () = {

+ pub struct Ref<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()> for Ref<T>

+ T: type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>,

+ {

+ type Lowered = &'lt type_name::Lowered<'lt, 'ctx, T>;

+ }

+ impl<'lt, 'ctx, T: ?Sized> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()> for &'lt T

+ T: type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>,

+ {

+ type Raised = Ref<type_name::Raised<'lt, 'ctx, T>>;

+ }

+};

+const _: () = {

+ pub struct Mut<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()> for Mut<T>

+ where

+ T: type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>,

+ {

+ type Lowered = &'lt mut type_name::Lowered<'lt, 'ctx, T>;

+ impl<'lt, 'ctx, T: ?Sized> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()> for &'lt mut T

+ where

+ T: type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>,

+ {

+ type Raised = Mut<type_name::Raised<'lt, 'ctx, T>>;

+};

+macro_rules! trait_by_id {

+ &

+ $this:ident,

+ $id:ident,

+ type Impls<$lt:lifetime, $ctx:lifetime> = ($($trait:ty),* $(,)?);

+ $($body:tt)*

+ }

+ } => {{

+ match $id {

+ $(

+ $id if $id == $crate::any::WithLtTypeId::of::<$trait>() => {

+ Some($crate::any::RefAnyUnsized::new($this as &$trait))

+ )*

+ _ => { $($body)* }

+ }};

+ &mut

+ $this:ident,

+ $id:ident,

+ {

+ type Impls<$lt:lifetime, $ctx:lifetime> = ($($trait:ty),* $(,)?);

+ $($body:tt)*

+ } => {{

+ match $id {

+ $(

+ $id if {

+ eprintln!("a: {:?}\nb: {:?}", &$id, $crate::any::WithLtTypeId::of::<$trait>());

+ $id == $crate::any::WithLtTypeId::of::<$trait>()

+ }=> {

+ Some($crate::any::MutAnyUnsized::new($this as &mut $trait))

+ }

+ )*

+ _ => { $($body)* }

+ }};

+#[doc(inline)]

+pub use trait_by_id;

+use core::{

+ marker::PhantomData,

+ mem::{ManuallyDrop, MaybeUninit},

+};

+

+/// Tiny version of dungeon-cell's DungeonCore.

+///

+/// Can be used to erase types. This container **will not**

+/// run the stored value's Drop impl. Also this container does not

+/// track what type it is storing. Also, also this container

+/// does not align it's value so no making borrows of the inner value!.

+///

+/// This type **is** safe to use in const environments.

+pub struct Erased<const N: usize> {

+ /// A value of some unknown type that is N bytes long.

+ ///

+ /// We don't need a UnsafeCell here because we never give out a borrow

+ /// of the value.

+ bytes: MaybeUninit<[u8; N]>,

+

+ _marker: PhantomData<*const ()>,

+}

+

+impl<const N: usize> Erased<N> {

+ /// Erase the type of a value.

+ pub const fn new<T>(value: T) -> Self {

+ const {

+ assert!(core::mem::size_of::<T>() <= N);

+ }

+

+ let value = ManuallyDrop::new(value);

+

+ #[repr(C)]

+ union Transmute<T, const N: usize> {

+ value: ManuallyDrop<T>,

+ bytes: MaybeUninit<[u8; N]>,

+ }

+

+ Self {

+ #[allow(unsafe_code)]

+ bytes: unsafe { Transmute { value }.bytes },

+ _marker: PhantomData,

+ }

+ }

+

+ /// Extract the original value.

+ ///

+ /// # Safety

+ /// `T` must be the same type used when [`Self::new`] was called.

+ #[allow(unsafe_code)]

+ pub const unsafe fn into_inner<T>(self) -> T {

+ const {

+ // This should already be covered by new, but here for completeness.

+ assert!(core::mem::size_of::<T>() <= N);

+ }

+

+ #[repr(C)]

+ union Transmute<T, const N: usize> {

+ bytes: MaybeUninit<[u8; N]>,

+ value: ManuallyDrop<T>,

+ }

+

+ ManuallyDrop::into_inner(unsafe { Transmute { bytes: self.bytes }.value })

+ }

+}

+use crate::hkt::CovariantLt;

+

+use super::{erased::Erased, type_name, WithLtTypeId};

+

+/// Type erased mutable borrow of a unsized type.

+///

+/// This type acts like a `&'a mut dyn Trait<'ctx> + 'lt` with the `Trait` part erased.

+/// This type exists to get a mutable borrow of an arbitrary trait object out of a object safe method.

+/// However, it is not limited to storing mutable borrows of trait objects. It can be

+/// used to store a mutable borrow to any type including sized ones.

+pub struct MutAnyUnsized<'a, 'lt, 'ctx> {

+ /// As shown in the table at https://doc.rust-lang.org/nomicon/subtyping.html#variance

+ /// mutable borrows are covariant over their lifetime, so we are also.

+ _a: CovariantLt<'a>,

+

+ /// The type erased borrow.

+ ///

+ /// This should be able to store any unsized type in current Rust as all of

+ /// them are 2 usize in width.

+ borrow: Erased<{ core::mem::size_of::<&mut dyn core::any::Any>() }>,

+

+ /// We use a function here to reduce the size down to one usize.

+ /// This makes a RefAnyUnsized only 3 usize wide.

+ type_name_id: fn() -> WithLtTypeId<'lt, 'ctx>,

+}

+

+impl<'a, 'lt: 'a, 'ctx: 'lt> MutAnyUnsized<'a, 'lt, 'ctx> {

+ /// Create from a borrow.

+ pub fn new<T: ?Sized + type_name::WithLt<'lt, 'ctx>>(borrow: &'a mut T) -> Self {

+ Self {

+ _a: CovariantLt::NEW,

+ borrow: Erased::new::<&'a mut T>(borrow),

+ type_name_id: || WithLtTypeId::of::<T>(),

+ }

+ }

+

+ /// Downcast the type erased value back to its original type.

+ pub fn downcast<T: ?Sized + type_name::WithLt<'lt, 'ctx>>(self) -> Result<&'a mut T, Self> {

+ if (self.type_name_id)() == WithLtTypeId::of::<T>() {

+ #[allow(unsafe_code)]

+ Ok(unsafe { self.borrow.into_inner::<&'a mut T>() })

+ } else {

+ Err(self)

+ }

+ }

+}

+use crate::hkt::CovariantLt;

+

+use super::{erased::Erased, type_name, WithLtTypeId};

+

+/// Type erased borrow of a unsized type.

+///

+/// This type acts like a `&'a dyn Trait<'ctx> + 'lt` with the `Trait` part erased.

+/// This type exists to get a borrow of an arbitrary trait object out of a object safe method.

+/// However, it is not limited to storing borrows of trait objects. It can be

+/// used to store a borrow to any type including sized ones.

+pub struct RefAnyUnsized<'a, 'lt, 'ctx> {

+ /// As shown in the table at https://doc.rust-lang.org/nomicon/subtyping.html#variance

+ /// borrows are covariant over their lifetime, so we are also.

+ _a: CovariantLt<'a>,

+

+ /// The type erased borrow.

+ ///

+ /// This should be able to store any unsized type in current Rust as all of

+ /// them are 2 usize in width.

+ borrow: Erased<{ core::mem::size_of::<&dyn core::any::Any>() }>,

+

+ /// We would prefer to be covariant over 'lt and 'ctx to match borrows,

+ /// but this would break the safety requirements of transmuting the type.

+ /// So instead they are invariant as given by WithLtTypeId.

+ ///

+ /// We use a function here to reduce the size down to one usize.

+ /// This makes a RefAnyUnsized only 3 usize wide.

+ type_name_id: fn() -> WithLtTypeId<'lt, 'ctx>,

+}

+

+impl<'a, 'lt: 'a, 'ctx: 'lt> RefAnyUnsized<'a, 'lt, 'ctx> {

+ /// Create from a borrow.

+ pub fn new<T: ?Sized + type_name::WithLt<'lt, 'ctx>>(borrow: &'a T) -> Self {

+ Self {

+ _a: CovariantLt::NEW,

+ borrow: Erased::new::<&'a T>(borrow),

+ type_name_id: || WithLtTypeId::of::<T>(),

+ }

+ }

+

+ /// Downcast the type erased value back to its original type.

+ pub fn downcast<T: ?Sized + type_name::WithLt<'lt, 'ctx>>(self) -> Result<&'a T, Self> {

+ if (self.type_name_id)() == WithLtTypeId::of::<T>() {

+ #[allow(unsafe_code)]

+ Ok(unsafe { self.borrow.into_inner::<&'a T>() })

+ } else {

+ Err(self)

+ }

+ }

+}

+/// Named `T` where `T: 'static`.

+impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()> for OwnedStatic<T> {

+ type Lowered = OwnedStatic<T>;

+impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()> for OwnedStatic<T> {

+ type Raised = OwnedStatic<T>;

+/// Named `&'ctx T` where` T: 'static`.

+const _: () = {

+ pub struct BorrowedStaticHrt<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>

+ for BorrowedStaticHrt<T>

+ {

+ type Lowered = BorrowedStatic<'ctx, T>;

+ }

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>

+ for BorrowedStatic<'ctx, T>

+ {

+ type Raised = BorrowedStaticHrt<T>;

+ }

+};

+/// Named `&'lt T` where` T: 'static`.

+pub struct TempBorrowedStatic<'lt, T: ?Sized>(pub &'lt T);

+const _: () = {

+ pub struct TempBorrowedStaticHrt<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>

+ for TempBorrowedStaticHrt<T>

+ {

+ type Lowered = TempBorrowedStatic<'lt, T>;

+ }

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>

+ for TempBorrowedStatic<'lt, T>

+ {

+ type Raised = TempBorrowedStaticHrt<T>;

+ }

+};

+/// Named `&'ctx mut T` where` T: 'static`.

+const _: () = {

+ pub struct BorrowedMutStaticHrt<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>

+ for BorrowedMutStaticHrt<T>

+ {

+ type Lowered = BorrowedMutStatic<'ctx, T>;

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>

+ for BorrowedMutStatic<'ctx, T>

+ {

+ type Raised = BorrowedMutStaticHrt<T>;

+};

+/// Named `&'lt mut T` where` T: 'static`.

+#[derive(PartialEq, Debug, SendSync)]

+#[repr(transparent)]

+pub struct TempBorrowedMutStatic<'lt, T: ?Sized>(pub &'lt mut T);

+const _: () = {

+ pub struct TempBorrowedMutStaticHrt<T: ?Sized>(Marker<T>);

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Lower<'lt, 'ctx, &'lt &'ctx ()>

+ for TempBorrowedMutStaticHrt<T>

+ {

+ type Lowered = TempBorrowedMutStatic<'lt, T>;

+ impl<'lt, 'ctx, T: ?Sized + 'static> type_name::Raise<'lt, 'ctx, &'lt &'ctx ()>

+ for TempBorrowedMutStatic<'lt, T>

+ {

+ type Raised = TempBorrowedMutStaticHrt<T>;

+};

+//! Bijective mapping between types with and without lifetimes.

+//!

+//! Types that implement [`Static`] contain no lifetimes (other than `'static`).

+//! Types that implement [`WithLt`] contain zero, one, or two lifetimes.

+//! The [`Raised`] and [`Lowered`] type aliases can be used to switch between the

+//! type having the lifetimes and the type that doesn't.

+//!

+//! In type theory terms, [`Static`] types represent type constructors needing

+//! the two lifetimes `'lt` and `'ctx` (where `'ctx` outlives `'lt`).

+//! [`WithLt`] represents the types that have a type constructor of the [`Static`]

+//! form.

+

+/// Lowers a higher ranked type to one with specific lifetimes.

+///

+/// This acts to *add* the `'lt` and `'ctx` lifetime to the type.

+///

+/// Note the `Bound` generic exists for implied lifetime bounds to make

+/// `'ctx: 'lt` work with Rust's `for<'a>` syntax.

+pub trait Lower<'lt, 'ctx: 'lt, Bound>: 'static {

+ /// The lowered type with lifetimes.

+ type Lowered: ?Sized + Raise<'lt, 'ctx, &'lt &'ctx (), Raised = Self>;

+}

+

+/// Raises a type to one without lifetimes.

+///

+/// This acts to *subtract* the `'lt` and `'ctx` lifetime from the type.

+///

+/// Note the `Bound` generic exists for implied lifetime bounds to make

+/// `'ctx: 'lt` work with Rust's `for<'a>` syntax.

+pub trait Raise<'lt, 'ctx: 'lt, Bound>: 'lt {

+ /// The raised type without lifetimes.

+ type Raised: ?Sized + Lower<'lt, 'ctx, &'lt &'ctx (), Lowered = Self>;

+}

+

+/// A type without lifetimes (other than `'static`).

+///

+/// These types can be lowered to types with lifetimes using [`Lowered`].

+pub trait Static: 'static + for<'lt, 'ctx> Lower<'lt, 'ctx, &'lt &'ctx ()> {}

+

+impl<T: ?Sized> Static for T where T: 'static + for<'lt, 'ctx> Lower<'lt, 'ctx, &'lt &'ctx ()> {}

+

+/// A type with zero, one, or two lifetimes.

+///

+/// These types can be raised to types without lifetimes using [`Raised`].

+pub trait WithLt<'lt, 'ctx: 'lt>: Raise<'lt, 'ctx, &'lt &'ctx ()> {}

+

+impl<'lt, 'ctx: 'lt, T: ?Sized> WithLt<'lt, 'ctx> for T where T: Raise<'lt, 'ctx, &'lt &'ctx ()> {}

+

+/// Add lifetimes to a type without them.

+pub type Lowered<'lt, 'ctx, T> = <T as Lower<'lt, 'ctx, &'lt &'ctx ()>>::Lowered;

+

+/// Remove lifetimes from a type with them.

+pub type Raised<'lt, 'ctx, T> = <T as Raise<'lt, 'ctx, &'lt &'ctx ()>>::Raised;

+

+fn _is_bijective_raise<'lt, 'ctx: 'lt, T>(x: Lowered<'lt, 'ctx, Raised<'lt, 'ctx, T>>)

+where

+ T: WithLt<'lt, 'ctx>,

+{

+ // This assignment shows T == Lowered<Raised<T>>

+ let _y: T = x;

+}

+

+fn _is_bijective_lower<'lt, 'ctx: 'lt, U>(x: Raised<'lt, 'ctx, Lowered<'lt, 'ctx, U>>)

+where

+ U: Static,

+{

+ // This assignment shows U == Raised<Lowered<U>>

+ let _y: U = x;

+}

+

+// A = set of Static types

+// B = set of lifetime types

+//

+// We only need one of the functions above to show its a bijection.

+// If we go a -> b -> a (a: A, b: B) for any a in A

+// then we know that there must only exist cycles of length 2.

+// This doesn't not however prove by itself that the b we encountered

+// is not reused. For that we must consider that we do b -> a using

+// Raised which has no information about the a we came from.

+// As such, no other a could exist that uses b in it's cycle.

+// This proves the two sets are of equal size and that the Lowered

+// and Raised form a bijective mapping both ways.

+//

+// Impossible:

+//

+// struct A;

+// struct B;

+// struct C;

+//

+// impl<'a, 'b> Lower<'a, 'b, &'a &'b ()> for A {

+// type Lowered = B;

+// }

+//

+// impl<'a, 'b> Raise<'a, 'b, &'a &'b ()> for B {

+// type Raised = A;

+// }

+//

+// impl<'a, 'b> Lower<'a, 'b, &'a &'b ()> for C {

+// type Lowered = B;

+// }

+use crate::hkt::Invariant;

+use super::type_name;

+/// [`TypeId`] for lifetime containing types.

+///

+/// This type supports a max of two lifetimes `'lt` and `'ctx`.

+/// Which are expected to be used like `dyn Trait<'ctx> + 'lt`.

+/// [`TypeId`] only allows `'static` types.

+/// This ID type splits the borrows out so that the borrow checker can check

+/// them independently. This does mean we must check the lifetimes at compile time.

+/// When `id_a == id_b` then the types are equal including the lifetimes.

+/// As such unsafe code can use this property to transmute values.

+pub struct WithLtTypeId<'lt, 'ctx> {

+ /// We are invariant over 'lt so the borrow checker checks it for

+ /// equality when doing `==`.

+ _lt: Invariant<'lt>,

+

+ /// We are invariant over 'ctx so the borrow checker checks it for

+ /// equality when doing `==`.

+ _ctx: Invariant<'ctx>,

+

+ /// Type ID of the higher ranked type.

+ higher_type_id: TypeId,

+impl<'lt, 'ctx: 'lt> WithLtTypeId<'lt, 'ctx> {

+ pub fn of<T: ?Sized + type_name::WithLt<'lt, 'ctx>>() -> Self {

+ _lt: Invariant::NEW,

+ _ctx: Invariant::NEW,

+ // We get the TypeId of the 'static higher ranked type.

+ higher_type_id: TypeId::of::<type_name::Raised<'lt, 'ctx, T>>(),

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

+impl<'lt, 'ctx> core::fmt::Debug for WithLtTypeId<'lt, 'ctx> {

+ core::fmt::Debug::fmt(&self.higher_type_id, f)

+impl<'lt, 'ctx> PartialEq for WithLtTypeId<'lt, 'ctx> {

+ self.higher_type_id == other.higher_type_id

+impl<'lt, 'ctx> Eq for WithLtTypeId<'lt, 'ctx> {}

+impl<'lt, 'ctx> PartialOrd for WithLtTypeId<'lt, 'ctx> {

+ Some(self.higher_type_id.cmp(&other.higher_type_id))

+impl<'lt, 'ctx> Ord for WithLtTypeId<'lt, 'ctx> {

+ self.higher_type_id.cmp(&other.higher_type_id)

+impl<'lt, 'ctx> core::hash::Hash for WithLtTypeId<'lt, 'ctx> {

+ self.higher_type_id.hash(state);

+use crate::protocol::AsVisitor;

+/// The canonical builders for a type.

+///

+/// This trait associates a set of builders with the type.

+/// This trait is mainly used by the derive macros to automatically select a builder

+/// for a field or variant.

+///

+/// There can be one canonical builder per mode. The mode is specified by the `M` generic and

+/// can be any type. It is only used as a type level tag.

+ /// The canonical builder for mode `M`.

+ ///

+ /// This builder will build values of type `Self`.

+ any::AnyTrait,

+ walk::DynWalkerObjSafe,

+impl<'ctx> AnyTrait<'ctx> for NoopVisitor {}

+use effectful::environment::Environment;

+use effectful::bound::Dynamic;

+use crate::any::{type_name, OwnedStatic, TempBorrowedStatic};

+use crate::protocol::visitor::{DynRecoverableScope, Recoverable};

+ any::AnyTrait,

+ build::BuilderTypes,

+ visitor::{tags, Tag, Value, VisitResult},

+ walk::DynWalkerObjSafe,

+ Builder, Flow,

+ type ValueT: type_name::Static;

+ fn from_value<'a>(value: type_name::Lowered<'a, 'ctx, Self::ValueT>) -> Self::T;

+ for<'a> Dynamic<type_name::Lowered<'a, 'ctx, Info::ValueT>>: DynBind<E>,

+ Inner::Seed(_seed) => {

+ for<'a> Dynamic<type_name::Lowered<'a, 'ctx, Info::ValueT>>: DynBind<E>,

+impl<'ctx, Info, Mode, E: Environment> AnyTrait<'ctx> for EnumBuilder<'ctx, Info, Mode, E>

+where

+ E: Environment,

+ Info: EnumBuildInfo<'ctx, Mode, E>,

+ Dynamic<Info::T>: DynBind<E>,

+ for<'a> Dynamic<type_name::Lowered<'a, 'ctx, Info::ValueT>>: DynBind<E>,

+ for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+ Dynamic<OwnedStatic<u32>>: DynBind<E>,

+{

+// any_trait! {

+// impl['ctx, Info, Mode][E] EnumBuilder<'ctx, Info, Mode, E> = [

+// ValueProto<Info::ValueT, E>,

+// TagProto<tags::Variant, E>,

+// RecoverableProto<E>

+// ] ref {

+// let (_this, _id);

+// } else ref {

+// None

+// } mut {

+// let (this, id);

+//

+// // If a variant has been chosen, then forward everything to it's builder.

+// if matches!(this.inner, Inner::Builder { .. }) {

+// match &mut this.inner {

+// Inner::Builder { builder } => {

+// return Info::as_visitor(builder).0.upcast_to_id_mut(id)

+// }

+// _ => unreachable!(),

+// }

+// }

+// } else mut {

+// None

+// } where

+// E: Environment,

+// Info: EnumBuildInfo<'ctx, Mode, E>,

+// Dynamic<Info::T>: DynBind<E>,

+// for<'a> Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// Dynamic<OwnedStatic<u32>>: DynBind<E>,

+// }

+

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, Info::ValueT>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, Info::ValueT>>>, E>

+ type_name::Lowered<'value, 'ctx, Info::ValueT>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, Info::ValueT>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+impl<'ctx, Info, Mode, E: Environment> AnyTrait<'ctx> for VariantVisitor<'ctx, Info, Mode, E>

+ E: Environment,

+ Dynamic<OwnedStatic<u32>>: DynBind<E>,

+ for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// any_trait! {

+// impl['ctx, Info, Mode][E] VariantVisitor<'ctx, Info, Mode, E> = [

+// ValueProto<TempBorrowedStaticHrt<str>, E>,

+// ValueProto<OwnedStatic<u32>, E>,

+// ]

+// where

+// E: Environment,

+// Info: EnumBuildInfo<'ctx, Mode, E>,

+// Dynamic<OwnedStatic<u32>>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// }

+

+// impl<'ctx, Info, Mode, E: Environment> Value<'ctx, TempBorrowedStaticHrt<str>, E>

+// for VariantVisitor<'ctx, Info, Mode, E>

+// where

+// Info: EnumBuildInfo<'ctx, Mode, E>,

+// for<'a> Dynamic<TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>>: DynBind<E>,

+// {

+// fn visit<'a>(

+// &'a mut self,

+// TempBorrowedStatic(value): TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>,

+// ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>>>, E>

+// where

+// TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>: Sized,

+// 'ctx: 'a,

+// {

+// if let Some(variant) = Info::marker_from_name(value) {

+// self.marker = Some(variant);

+//

+// E::value(Flow::Done.into()).cast()

+// } else {

+// E::value(Flow::Continue.into()).cast()

+// }

+// }

+// }

+

+ for<'a> Dynamic<type_name::Lowered<'a, 'ctx, OwnedStatic<u32>>>: DynBind<E>,

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, OwnedStatic<u32>>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<u32>>>>, E>

+ type_name::Lowered<'value, 'ctx, OwnedStatic<u32>>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<u32>>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ if let Some(variant) = Info::marker_from_discriminant(value.0) {

+ bound::Dynamic,

+ any::{type_name, AnyTrait, OwnedStatic, TempBorrowedStatic},

+ build::BuilderTypes,

+ tags, DynSequenceScope, EffectiveVisitExt as _, RequestHint, Sequence, SequenceHint,

+ Tag, TagConst, TagHint, Value, VisitResult,

+ walk::DynWalkerObjSafe,

+ Builder, Flow,

+ type ValueT: type_name::Static;

+ fn from_value<'a>(value: type_name::Lowered<'a, 'ctx, Self::ValueT>) -> Self::T;

+ for<'b, 'c> Dynamic<type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b, 'c> Dynamic<&'b type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b, 'c> Dynamic<type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b, 'c> Dynamic<&'b type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+impl<'ctx, Info, Mode, E: Environment> AnyTrait<'ctx> for StructBuilder<'ctx, Info, Mode, E>

+where

+ for<'a> Dynamic<&'a Info::T>: DynBind<E>,

+ E: Environment,

+ Self: DynBind<E>,

+ Info: StructTypeInfo<'ctx, Mode, E>,

+ Dynamic<Info::T>: DynBind<E>,

+ Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+ Dynamic<OwnedStatic<String>>: DynBind<E>,

+ for<'b, 'c> Dynamic<type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b, 'c> Dynamic<&'b type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b> Dynamic<TempBorrowedStatic<'b, str>>: DynBind<E>,

+ Dynamic<OwnedStatic<usize>>: DynBind<E>,

+ Dynamic<Info::T>: DynBind<E>,

+ Mode: 'ctx,

+{

+// any_trait! {

+// impl['ctx, Info, Mode][E] StructBuilder<'ctx, Info, Mode, E> = [

+// RequestHintProto<E>,

+// ValueProto<Info::ValueT, E>,

+// TagProto<tags::Struct, E>,

+// TagProto<tags::Map, E>,

+// SequenceProto<E>

+// ] where

+// for<'a> Dynamic<&'a Info::T>: DynBind<E>,

+// E: Environment,

+// Self: DynBind<E>,

+// Info: StructTypeInfo<'ctx, Mode, E>,

+// Dynamic<Info::T>: DynBind<E>,

+// Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+// Dynamic<OwnedStatic<String>>: DynBind<E>,

+// for<'b, 'c> Dynamic<TypeName::T<'b, 'c, Info::ValueT, E>>: DynBind<E>,

+// for<'b, 'c> Dynamic<&'b TypeName::T<'b, 'c, Info::ValueT, E>>: DynBind<E>,

+// for<'b> Dynamic<TempBorrowedStatic<'b, str>>: DynBind<E>,

+// Dynamic<OwnedStatic<usize>>: DynBind<E>,

+// Dynamic<Info::T>: DynBind<E>,

+// Mode: 'ctx,

+// }

+

+ for<'b, 'c> Dynamic<type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ for<'b, 'c> Dynamic<&'b type_name::Lowered<'b, 'c, Info::ValueT>>: DynBind<E>,

+ hint_protocol::<dyn Value<'_, Info::ValueT, E>, _, _>(walker.cast(), *this, ())

+ .cast()

+ hint_protocol::<dyn Tag<'_, tags::Struct, E>, _, _>(

+ hint_protocol::<dyn Tag<'_, tags::Map, E>, _, _>(

+ hint_protocol::<dyn Sequence<'_, E>, _, _>(

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, Info::ValueT>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, Info::ValueT>>>, E>

+ type_name::Lowered<'value, 'ctx, Info::ValueT>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, Info::ValueT>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+impl<'a, 'ctx, I: StructTypeInfo<'ctx, M, E>, M, E: Environment> AnyTrait<'ctx>

+ for FieldVisitor<'a, 'ctx, I, M, E>

+where

+ E: Environment,

+ I: StructTypeInfo<'ctx, M, E>,

+ Dynamic<OwnedStatic<usize>>: DynBind<E>,

+ Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+ Dynamic<OwnedStatic<String>>: DynBind<E>,

+ for<'b> Dynamic<TempBorrowedStatic<'b, str>>: DynBind<E>,

+{

+// any_trait! {

+// impl['ctx, 'a, I, M][E] FieldVisitor<'a, 'ctx, I, M, E> = [

+// TagProto<tags::Key, E>,

+// ] ref {

+// let (_this, _id);

+// } else ref {

+// None

+// } mut {

+// let (this, id);

+// } else mut {

+// this.marker.and_then(|marker| {

+// I::as_visitor(marker, this.builders).0.upcast_to_id_mut(id)

+// })

+// } where

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E>,

+// Dynamic<OwnedStatic<usize>>: DynBind<E>,

+// Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+// Dynamic<OwnedStatic<String>>: DynBind<E>,

+// for<'b> Dynamic<TempBorrowedStatic<'b, str>>: DynBind<E>,

+// }

+

+impl<'ctx, I: StructTypeInfo<'ctx, M, E>, M, E: Environment> AnyTrait<'ctx>

+ for NameVisitor<'ctx, I, M, E>

+ Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+ Dynamic<OwnedStatic<String>>: DynBind<E>,

+ for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// any_trait! {

+// impl['ctx, I, M][E] NameVisitor<'ctx, I, M, E> = [

+// ValueProto<OwnedStatic<usize>, E>,

+// ValueProto<TempBorrowedStaticHrt<str>, E>,

+// ValueProto<OwnedStatic<&'static str>, E>,

+// ValueProto<OwnedStatic<String>, E>,

+// ] where

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E>,

+// Dynamic<OwnedStatic<usize>>: DynBind<E>,

+// Dynamic<OwnedStatic<&'static str>>: DynBind<E>,

+// Dynamic<OwnedStatic<String>>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// }

+

+impl<'ctx, I, M, E> Value<'ctx, OwnedStatic<usize>, E> for NameVisitor<'ctx, I, M, E>

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, OwnedStatic<usize>>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<usize>>>>, E>

+ type_name::Lowered<'value, 'ctx, OwnedStatic<usize>>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<usize>>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ self.field_marker = I::marker_from_index(value.0);

+// impl<'ctx, I, M, E> Value<'ctx, TempBorrowedStatic<str>, E> for NameVisitor<'ctx, I, M, E>

+// where

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,

+// {

+// fn visit<'a>(

+// &'a mut self,

+// TempBorrowedStatic(name): TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>,

+// ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>>>, E>

+// where

+// TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>: Sized,

+// 'ctx: 'a,

+// {

+// self.field_marker = I::marker_from_name(name);

+//

+// E::value(VisitResult::Control(Flow::Done)).cast()

+// }

+// }

+

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, OwnedStatic<&'static str>>,

+ ) -> NativeForm<

+ 'e,

+ VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<&'static str>>>>,

+ E,

+ >

+ type_name::Lowered<'value, 'ctx, OwnedStatic<&'static str>>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<&'static str>>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ self.field_marker = I::marker_from_name(value.0);

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, OwnedStatic<String>>,

+ ) -> NativeForm<

+ 'e,

+ VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<String>>>>,

+ E,

+ >

+ type_name::Lowered<'value, 'ctx, OwnedStatic<String>>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<String>>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ self.field_marker = I::marker_from_name(&value.0);

+ type_name, AnyTrait, BorrowedMutStatic, BorrowedStatic, OwnedStatic, TempBorrowedMutStatic,

+ TempBorrowedStatic,

+ visitor::{EffectiveVisitExt as _, RequestHint, Value, VisitResult},

+ trait_by_id, Flow,

+impl<T, Clone, E: Environment> crate::build::BuilderTypes<E> for ValueBuilder<T, Clone, E>

+ Self: AnyTrait<'ctx>,

+ Self: AnyTrait<'ctx> + DynBind<E>,

+impl<'ctx, T: 'static, E: Environment> AnyTrait<'ctx> for ValueBuilder<T, NotCloneable, E>

+where

+ Dynamic<T>: DynBind<E>,

+ for<'a> Dynamic<&'a T>: DynBind<E>,

+ Dynamic<OwnedStatic<T>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<T>>: DynBind<E>,

+{

+ fn upcast_by_id_mut<'a, 'lt: 'a>(

+ &'a mut self,

+ id: crate::any::WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<crate::any::MutAnyUnsized<'a, 'lt, 'ctx>>

+ where

+ 'ctx: 'lt,

+ {

+ trait_by_id!(&mut self, id, {

+ type Impls<'lt, 'ctx> = (dyn RequestHint<'ctx, E>, dyn Value<'ctx, OwnedStatic<T>, E>);

+

+ None

+ })

+ }

+impl<'ctx, T: 'static + Clone, E: Environment> AnyTrait<'ctx> for ValueBuilder<T, Cloneable, E>

+where

+ Dynamic<T>: DynBind<E>,

+ for<'a> Dynamic<&'a T>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<T>>: DynBind<E>,

+ Dynamic<OwnedStatic<T>>: DynBind<E>,

+ Dynamic<BorrowedStatic<'ctx, T>>: DynBind<E>,

+ for<'a, 'b> Dynamic<&'a BorrowedStatic<'b, T>>: DynBind<E>,

+ for<'a> Dynamic<TempBorrowedStatic<'a, T>>: DynBind<E>,

+ for<'a> Dynamic<&'a TempBorrowedStatic<'a, T>>: DynBind<E>,

+ Dynamic<BorrowedMutStatic<'ctx, T>>: DynBind<E>,

+ for<'a, 'b> Dynamic<&'a BorrowedMutStatic<'b, T>>: DynBind<E>,

+ for<'a> Dynamic<TempBorrowedMutStatic<'a, T>>: DynBind<E>,

+ for<'a> Dynamic<&'a TempBorrowedMutStatic<'a, T>>: DynBind<E>,

+{

+ fn upcast_by_id_mut<'a, 'lt: 'a>(

+ &'a mut self,

+ id: crate::any::WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<crate::any::MutAnyUnsized<'a, 'lt, 'ctx>>

+ where

+ 'ctx: 'lt,

+ {

+ dbg!(&id);

+ trait_by_id!(&mut self, id, {

+ type Impls<'lt, 'ctx> = (dyn RequestHint<'ctx, E>, dyn Value<'ctx, OwnedStatic<T>, E>);

+

+ None

+ })

+ }

+// any_trait! {

+// impl['ctx, T][E] ValueBuilder<T, NotCloneable, E> = [

+// RequestHintProto<E>,

+// ValueProto<OwnedStatic<T>, E>,

+// ] where

+// E: Environment,

+// T: 'static,

+// Dynamic<T>: DynBind<E>,

+// for<'a> Dynamic<&'a T>: DynBind<E>,

+// Dynamic<OwnedStatic<T>>: DynBind<E>,

+// for<'a> Dynamic<&'a OwnedStatic<T>>: DynBind<E>,

+// }

+//

+// any_trait! {

+// impl['ctx, T][E] ValueBuilder<T, Cloneable, E> = [

+// RequestHintProto<E>,

+// ValueProto<OwnedStatic<T>, E>,

+// ValueProto<BorrowedStaticHrt<T>, E>,

+// ValueProto<TempBorrowedStaticHrt<T>, E>,

+// ValueProto<BorrowedMutStaticHrt<T>, E>,

+// ValueProto<TempBorrowedMutStaticHrt<T>, E>,

+// ] where

+// E: Environment,

+// T: 'static + Clone,

+// Dynamic<T>: DynBind<E>,

+// for<'a> Dynamic<&'a T>: DynBind<E>,

+// for<'a> Dynamic<&'a OwnedStatic<T>>: DynBind<E>,

+// Dynamic<OwnedStatic<T>>: DynBind<E>,

+// Dynamic<BorrowedStatic<'ctx, T>>: DynBind<E>,

+// for<'a, 'b> Dynamic<&'a BorrowedStatic<'b, T>>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, T>>: DynBind<E>,

+// for<'a> Dynamic<&'a TempBorrowedStatic<'a, T>>: DynBind<E>,

+// Dynamic<BorrowedMutStatic<'ctx, T>>: DynBind<E>,

+// for<'a, 'b> Dynamic<&'a BorrowedMutStatic<'b, T>>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedMutStatic<'a, T>>: DynBind<E>,

+// for<'a> Dynamic<&'a TempBorrowedMutStatic<'a, T>>: DynBind<E>,

+// }

+

+ hint_protocol::<dyn Value<'_, OwnedStatic<T>, E>, _, _>(walker.cast(), *this, ()).cast()

+ hint_protocol::<dyn Value<'_, OwnedStatic<T>, E>, _, _>(walker.cast(), *this, ())

+ .cast()

+ hint_protocol::<

+ dyn Value<'_, type_name::Raised<'_, '_, BorrowedStatic<'_, T>>, E>,

+ _,

+ _,

+ >(walker.cast(), *this, ())

+ .cast()

+ hint_protocol::<

+ dyn Value<'_, type_name::Raised<'_, '_, TempBorrowedStatic<'_, T>>, E>,

+ _,

+ _,

+ >(walker.cast(), *this, ())

+ hint_protocol::<

+ dyn Value<'_, type_name::Raised<'_, '_, BorrowedMutStatic<'_, T>>, E>,

+ _,

+ _,

+ >(walker.cast(), *this, ())

+ .cast()

+ hint_protocol::<

+ dyn Value<'_, type_name::Raised<'_, '_, TempBorrowedMutStatic<'_, T>>, E>,

+ _,

+ _,

+ >(walker.cast(), *this, ())

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, OwnedStatic<T>>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<T>>>>, E>

+ type_name::Lowered<'value, 'ctx, OwnedStatic<T>>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, OwnedStatic<T>>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ self.value = Some(Dynamic(value.0));

+impl<'ctx, T: 'static, E: Environment>

+ Value<'ctx, type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, T>>, E>

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<

+ 'value,

+ 'ctx,

+ type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, T>>,

+ >,

+ ) -> NativeForm<

+ 'e,

+ VisitResult<

+ Dynamic<

+ type_name::Lowered<

+ 'value,

+ 'ctx,

+ type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, T>>,

+ >,

+ >,

+ >,

+ E,

+ >

+ type_name::Lowered<'value, 'ctx, type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, T>>>:

+ Sized,

+ Dynamic<

+ type_name::Lowered<

+ 'value,

+ 'ctx,

+ type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, T>>,

+ >,

+ >: DynBind<E>,

+ 'ctx: 'this + 'value,

+ self.value = Some(Dynamic(value.0.clone()));

+// impl<'ctx, T: 'static, E: Environment>

+// Value<'ctx, type_name::Raised<'static, 'ctx, TempBorrowedStatic<'static, T>>, E>

+// for ValueBuilder<T, Cloneable, E>

+// where

+// T: Clone,

+// Dynamic<T>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedStatic<'a, T>>: DynBind<E>,

+// {

+// fn visit<'a>(

+// &'a mut self,

+// TempBorrowedStatic(value): TempBorrowedStatic<'a, T>,

+// ) -> NativeForm<'a, VisitResult<Dynamic<TempBorrowedStatic<'a, T>>>, E>

+// where

+// 'ctx: 'a,

+// {

+// self.value = Some(Dynamic(value.clone()));

+//

+// E::value(Flow::Done.into()).cast()

+// }

+// }

+//

+// impl<'ctx, T: 'static, E: Environment> Value<'ctx, BorrowedMutStatic<'ctx, T>, E>

+// for ValueBuilder<T, Cloneable, E>

+// where

+// T: Clone,

+// Dynamic<T>: DynBind<E>,

+// Dynamic<BorrowedMutStatic<'ctx, T>>: DynBind<E>,

+// {

+// fn visit<'a>(

+// &'a mut self,

+// BorrowedMutStatic(value): BorrowedMutStatic<'ctx, T>,

+// ) -> NativeForm<'a, VisitResult<Dynamic<BorrowedMutStatic<'ctx, T>>>, E>

+// where

+// 'ctx: 'a,

+// {

+// self.value = Some(Dynamic(value.clone()));

+//

+// E::value(Flow::Done.into()).cast()

+// }

+// }

+//

+// impl<'ctx, T: 'static, E: Environment>

+// Value<'ctx, type_name::Raised<'static, 'ctx, BorrowedMutStatic<'static, T>>, E>

+// for ValueBuilder<T, Cloneable, E>

+// where

+// T: Clone,

+// Dynamic<T>: DynBind<E>,

+// for<'a> Dynamic<TempBorrowedMutStatic<'a, T>>: DynBind<E>,

+// {

+// fn visit<'a>(

+// &'a mut self,

+// TempBorrowedMutStatic(value): TempBorrowedMutStatic<'a, T>,

+// ) -> NativeForm<'a, VisitResult<Dynamic<TempBorrowedMutStatic<'a, T>>>, E>

+// where

+// 'ctx: 'a,

+// {

+// self.value = Some(Dynamic(value.clone()));

+//

+// E::value(Flow::Done.into()).cast()

+// }

+// }

+impl<'a> Invariant<'a> {

+ pub const NEW: Self = Self(PhantomData);

+}

+

+#[derive(Debug, Default, Copy, Clone, SendSync)]

+#[repr(transparent)]

+pub struct CovariantLt<'a>(PhantomData<&'a ()>);

+

+impl<'a> CovariantLt<'a> {

+ pub const NEW: Self = Self(PhantomData);

+}

+

+pub mod build;

+pub mod mode;

+pub mod transform;

+pub mod walk;

+#[doc(inline)]

+pub use build::{Build, Builder};

+#[doc(inline)]

+pub use walk::{Walk, Walker};

+type Never = std::convert::Infallible;

+

+impl ConvertShort<Flow> for Option<Never> {

+ $crate::build::builders::core::r#struct::StructBuilder<'ctx, __Info, M, E>: $crate::Builder<'ctx, E, Value = Self>

+ type Builder = $crate::build::builders::core::r#struct::StructBuilder<'ctx, __Info, M, E>;

+ $($field(<<$type as $crate::Build<'ctx, M, E>>::Builder as $crate::build::BuilderTypes<E>>::Error)),*

+ impl<'ctx, M: 'ctx, E: effectful::environment::Environment> $crate::build::builders::core::r#struct::StructTypeInfo<'ctx, M, E> for __Info

+ type Seed = ($(<<$type as $crate::Build<'ctx, M, E>>::Builder as $crate::build::BuilderTypes<E>>::Seed),*);

+ use $crate::build::BuilderTypes;

+ $crate::build::builders::core::r#enum::EnumBuilder<'ctx, __Info, M, E>: $crate::Builder<'ctx, E, Value = Self>

+ type Builder = $crate::build::builders::core::r#enum::EnumBuilder<'ctx, __Info, M, E>;

+ impl<'ctx, M: 'ctx, E: effectful::environment::Environment> $crate::build::builders::core::r#enum::EnumBuildInfo<'ctx, M, E> for __Info

+pub enum DefaultMode {}

+pub enum StrictMode {}

+use effectful::{environment::Environment, SendSync};

+use effectful::environment::DynBind;

+use effectful::environment::EnvConfig;

+

+pub trait AnyTraitDynBind<'a, 'ctx, E: EnvConfig>: AnyTrait<'ctx> + DynBind<E> {

+ fn cast(&self) -> &(dyn AnyTrait<'ctx> + 'a);

+ fn cast_mut(&mut self) -> &mut (dyn AnyTrait<'ctx> + 'a);

+ fn cast_mut2(&mut self) -> &mut dyn AnyTrait<'ctx>;

+

+ fn cast_bind_mut<'b>(&'b mut self) -> &'b mut (dyn AnyTraitDynBind<'b, 'ctx, E> + 'b)

+ where

+ 'a: 'b;

+}

+

+impl<'a, 'ctx, E: EnvConfig, T> AnyTraitDynBind<'a, 'ctx, E> for T

+where

+ T: AnyTrait<'ctx> + DynBind<E> + 'a,

+{

+ fn cast(&self) -> &(dyn AnyTrait<'ctx> + 'a) {

+ self

+ }

+

+ fn cast_mut(&mut self) -> &mut (dyn AnyTrait<'ctx> + 'a) {

+ self

+ }

+

+ fn cast_mut2(&mut self) -> &mut dyn AnyTrait<'ctx> {

+ self

+ }

+

+ fn cast_bind_mut<'b>(&'b mut self) -> &'b mut (dyn AnyTraitDynBind<'b, 'ctx, E> + 'b)

+ where

+ 'a: 'b,

+ {

+ self

+ }

+}

+pub struct DynVisitor<'a, 'ctx, E: EnvConfig>(pub &'a mut (dyn AnyTraitDynBind<'a, 'ctx, E> + 'a));

+impl<'a, 'ctx, E: EnvConfig> DynVisitor<'a, 'ctx, E> {

+ pub fn cast<'b>(&'b mut self) -> DynVisitor<'b, 'ctx, E> {

+ DynVisitor(self.0.cast_bind_mut())

+impl<'a, 'ctx, E: EnvConfig> Deref for DynVisitor<'a, 'ctx, E> {

+ type Target = dyn AnyTrait<'ctx> + 'a;

+ self.0.cast()

+impl<'a, 'ctx, E: EnvConfig> DerefMut for DynVisitor<'a, 'ctx, E> {

+ self.0.cast_mut()

+pub trait AsVisitor<'ctx, E: EnvConfig> {

+ fn as_visitor<'a>(&'a mut self) -> DynVisitor<'a, 'ctx, E>

+impl<'b, 'ctx, E: EnvConfig> AsVisitor<'ctx, E> for DynVisitor<'b, 'ctx, E> {

+ fn as_visitor<'a>(&'a mut self) -> DynVisitor<'a, 'ctx, E>

+pub struct DynWalker<'a, 'ctx, E: EnvConfig>(pub &'a mut (dyn AnyTraitDynBind<'a, 'ctx, E> + 'a));

+impl<'a, 'ctx, E: EnvConfig> DynWalker<'a, 'ctx, E> {

+ pub fn cast<'b>(&'b mut self) -> DynWalker<'b, 'ctx, E> {

+ DynWalker(self.0.cast_bind_mut())

+impl<'a, 'ctx, E: EnvConfig> Deref for DynWalker<'a, 'ctx, E> {

+ type Target = dyn AnyTrait<'ctx> + 'a;

+ self.0.cast()

+impl<'a, 'ctx, E: EnvConfig> DerefMut for DynWalker<'a, 'ctx, E> {

+ self.0.cast_mut()

+use crate::{Flow, Status};

+ environment::{DynBind, Environment, InEnvironment, NativeForm},

+pub type IfSkippedEffective<'ctx, 'lt, 'wrap, Cap, Update, Eff> = SplitUpdateEffective<

+ 'wrap,

+ 'lt,

+ (),

+ (

+ Cap,

+ HasSendAndSync<

+ for<'a> fn(

+ Cap,

+ &'a mut Update,

+ )

+ -> NativeForm<'a, VisitResult<()>, <Eff as InEnvironment>::Env, &'ctx ()>,

+ >,

+ ),

+ Update,

+ VisitResult<()>,

+ VisitResult<()>,

+ Eff,

+>;

+

+type IfSkippedF<'ctx, Cap, Update, Eff> =

+ for<'a> fn(

+ Cap,

+ &'a mut Update,

+ ) -> NativeForm<'a, VisitResult<()>, <Eff as InEnvironment>::Env, &'ctx ()>;

+

+ f: IfSkippedF<'ctx, Cap, Update, Self>,

+ ) -> IfSkippedEffective<'ctx, 'lt, 'wrap, Cap, Update, Self>

+ f: IfSkippedF<'ctx, Cap, Update, Self>,

+ ) -> IfSkippedEffective<'ctx, 'lt, 'wrap, Cap, Update, Self>

+ environment::{DynBind, EnvConfig, Environment, InEnvironment, NativeForm},

+ higher_ranked::Rank1,

+ any::type_name,

+ protocol::{walker::hint::HintMeta, DynVisitor},

+const _: () = {

+ pub struct RecoverableProto<E>(Marker<E>);

+ impl<'a, 'ctx, E: 'static> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for RecoverableProto<E> {

+ type Lowered = dyn Recoverable<'ctx, E> + 'a;

+ }

+ impl<'a, 'ctx, E: 'static> type_name::Raise<'a, 'ctx, &'a &'ctx ()>

+ for dyn Recoverable<'ctx, E> + 'a

+ {

+ type Raised = RecoverableProto<E>;

+ }

+

+ impl<E: Environment> HintMeta for RecoverableProto<E> {

+ type Known = Rank1<()>;

+

+ type Hint = Rank1<()>;

+ }

+

+ impl<E: Environment> InEnvironment for RecoverableProto<E> {

+ type Env = E;

+ }

+};

+ if let Some(object) = visitor

+ .0

+ .cast_mut()

+ .upcast_mut::<dyn Recoverable<'ctx, E> + 'a>()

+ {

+ any::type_name,

+const _: () = {

+ pub struct RequestHintProto<E: Environment>(Marker<E>);

+ impl<'a, 'ctx, E> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for RequestHintProto<E>

+ where

+ E: Environment,

+ {

+ type Lowered = dyn RequestHint<'ctx, E> + 'a;

+ }

+ impl<'a, 'ctx, E> type_name::Raise<'a, 'ctx, &'a &'ctx ()> for dyn RequestHint<'ctx, E> + 'a

+ where

+ E: Environment,

+ {

+ type Raised = RequestHintProto<E>;

+ }

+};

+ if let Some(object) = visitor

+ .0

+ .cast_mut()

+ .upcast_mut::<dyn RequestHint<'ctx, E>>()

+ {

+ environment::{DynBind, EnvConfig, Environment, InEnvironment, NativeForm},

+ higher_ranked::Rank1,

+ any::type_name,

+ protocol::{walker::hint::HintMeta, DynVisitor},

+const _: () = {

+ pub struct SequenceProto<E: Environment>(Marker<E>);

+ impl<'a, 'ctx, E> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for SequenceProto<E>

+ where

+ E: Environment,

+ {

+ type Lowered = dyn Sequence<'ctx, E> + 'a;

+ }

+ impl<'a, 'ctx, E> type_name::Raise<'a, 'ctx, &'a &'ctx ()> for dyn Sequence<'ctx, E> + 'a

+ where

+ E: Environment,

+ {

+ type Raised = SequenceProto<E>;

+ }

+

+ impl<'a, 'ctx, E: Environment> HintMeta for SequenceProto<E> {

+ type Known = Rank1<SequenceKnown>;

+

+ type Hint = Rank1<SequenceHint>;

+ }

+

+ impl<'a, 'ctx, E: Environment> InEnvironment for SequenceProto<E> {

+ type Env = E;

+ }

+};

+ if let Some(object) = visitor

+ .0

+ .cast_mut()

+ .upcast_mut::<dyn Sequence<'ctx, E> + 'a>()

+ {

+ higher_ranked::Rank1,

+ any::type_name,

+ protocol::{walker::hint::HintMeta, DynVisitor},

+ walk::{DynWalkerAdapter, DynWalkerError, DynWalkerObjSafe},

+ Walker,

+pub trait ConstTagKind<E: EnvConfig>: TagKind<E> {

+ const NEW: Self;

+}

+

+impl<E: EnvConfig, const SYMBOL: u64> ConstTagKind<E> for TagConst<SYMBOL> {

+ const NEW: Self = TagConst;

+}

+

+ pub const VALUE: Symbol = Symbol::from_int(SYMBOL);

+const _: () = {

+ pub struct TagProto<K: TagKind<E>, E: Environment>(Marker<(K, E)>);

+ impl<'a, 'ctx, K: TagKind<E>, E> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for TagProto<K, E>

+ where

+ E: Environment,

+ {

+ type Lowered = dyn Tag<'ctx, K, E> + 'a;

+ }

+ impl<'a, 'ctx, K: TagKind<E>, E> type_name::Raise<'a, 'ctx, &'a &'ctx ()>

+ for dyn Tag<'ctx, K, E> + 'a

+ where

+ E: Environment,

+ {

+ type Raised = TagProto<K, E>;

+ }

+

+ impl<'a, 'ctx, K: TagKind<E>, E: Environment> HintMeta for TagProto<K, E> {

+ type Known = Rank1<TagKnown>;

+

+ type Hint = Rank1<TagHint<K>>;

+ }

+

+ impl<'a, 'ctx, K: TagKind<E>, E: Environment> effectful::environment::InEnvironment

+ for TagProto<K, E>

+ {

+ type Env = E;

+ }

+};

+ tri!(visitor.upcast_mut::<dyn Tag<'ctx, K, E>>())

+ tri!(visitor.upcast_mut::<dyn Tag<'ctx, TagDyn, E>>())

+ bound::Dynamic,

+ environment::{DynBind, Environment, NativeForm},

+ higher_ranked::{for_lt, Rank1},

+ any::type_name,

+ protocol::{walker::hint::HintMeta, DynVisitor},

+pub trait Value<'ctx, T: ?Sized + type_name::Static, E: Environment>: DynBind<E> {

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, T>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, T>>>, E>

+ type_name::Lowered<'value, 'ctx, T>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, T>>: DynBind<E>,

+ 'ctx: 'this + 'value;

+const _: () = {

+ pub struct ValueProto<T: ?Sized, E>(Marker<(*const T, E)>);

+ impl<'a, 'ctx, T: ?Sized, E> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for ValueProto<T, E>

+ where

+ E: Environment,

+ T: type_name::Static,

+ {

+ type Lowered = dyn Value<'ctx, T, E> + 'a;

+ }

+ impl<'a, 'ctx, T: ?Sized, E> type_name::Raise<'a, 'ctx, &'a &'ctx ()> for dyn Value<'ctx, T, E> + 'a

+ where

+ E: Environment,

+ T: type_name::Static,

+ {

+ type Raised = ValueProto<T, E>;

+ }

+

+ // This enrolls the Value protocol into the walker hint system.

+ impl<T, E: Environment> HintMeta for ValueProto<T, E>

+ where

+ T: ?Sized + type_name::Static,

+ {

+ type Known = for_lt!(<'b> ValueKnown<'b, T>);

+

+ type Hint = Rank1<()>;

+ }

+

+ impl<T: ?Sized, E: Environment> effectful::environment::InEnvironment for ValueProto<T, E> {

+ type Env = E;

+ }

+};

+ T: type_name::WithLt<'e, 'ctx>,

+ type_name::Raised<'e, 'ctx, T>: type_name::Static,

+ .cast_mut()

+ .upcast_mut::<dyn Value<'ctx, type_name::Raised<'e, 'ctx, T>, E> + '_>()

+ environment::{DynBind, EnvConfig, Environment, InEnvironment, NativeForm},

+ higher_ranked::{Hrt, WithLt},

+ any::{type_name, AnyTrait},

+ protocol::{visitor::VisitResult, AnyTraitDynBind, DynVisitor, DynWalker},

+pub trait HintMeta: InEnvironment + type_name::Static {

+ type Known: Hrt;

+ type Hint: Hrt;

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

+ hint: WithLt<'hint, Protocol::Hint>,

+ ) -> NativeForm<'e, VisitResult, Protocol::Env>

+ 'ctx: 'this + 'visitor + 'hint;

+ hint: &'a WithLt<'a, Protocol::Hint>,

+ ) -> NativeForm<'a, Result<WithLt<'a, Protocol::Known>, ()>, Protocol::Env>

+ where

+ WithLt<'a, Protocol::Known>: DynBind<Protocol::Env>;

+ visitor: DynVisitor<'temp, 'ctx, Protocol::Env>,

+ T: AnyTraitDynBind<'temp, 'ctx, Protocol::Env>,

+ pub fn as_known(&mut self) -> &mut type_name::Lowered<'temp, 'ctx, Protocol> {

+ self.visitor

+ .upcast_mut::<type_name::Lowered<'temp, 'ctx, Protocol>>()

+ .unwrap()

+ pub fn into_inner(self) -> DynVisitor<'temp, 'ctx, Protocol::Env> {

+ type Target = DynVisitor<'temp, 'ctx, Protocol::Env>;

+const _: () = {

+ pub struct HintProto<Protocol: ?Sized>(Marker<Protocol>);

+ impl<'a, 'ctx, Protocol: ?Sized> type_name::Lower<'a, 'ctx, &'a &'ctx ()> for HintProto<Protocol>

+ where

+ Protocol: HintMeta,

+ {

+ type Lowered = dyn Hint<'ctx, Protocol> + 'a;

+ }

+ impl<'a, 'ctx, Protocol: ?Sized> type_name::Raise<'a, 'ctx, &'a &'ctx ()>

+ for dyn Hint<'ctx, Protocol> + 'a

+ where

+ Protocol: HintMeta,

+ {

+ type Raised = HintProto<Protocol>;

+ }

+};

+ 'ctx: 'walker + 'visitor + 'hint,

+ Protocol: ?Sized + type_name::WithLt<'static, 'static>,

+ E,

+ walker: DynWalker<'walker, 'ctx, E>,

+ hint: WithLt<'hint, <type_name::Raised<'static, 'static, Protocol> as HintMeta>::Hint>,

+) -> NativeForm<'e, VisitResult<()>, E>

+ E: Environment,

+ T: AnyTrait<'ctx> + DynBind<E>,

+ type_name::Raised<'static, 'static, Protocol>: HintMeta<Env = E>,

+ if let Some(object) = walker

+ .0

+ .cast_mut2()

+ .upcast_mut::<dyn Hint<'ctx, type_name::Raised<'static, 'static, Protocol>> + '_>()

+ {

+ E::value(VisitResult::Skipped(())).cast()

+use crate::{build::Builder, build::BuilderTypes, Build, DefaultMode, Walk, Walker};

+ #[allow(clippy::type_complexity)]

+ any::AnyTrait,

+ any::{type_name, OwnedStatic},

+ request_hint, visit_value, EffectiveVisitExt as _, Value, ValueKnown, VisitResult,

+ walker::hint::{DynVisitorWith, Hint},

+ Walker,

+impl<'ctx, T, E> AnyTrait<'ctx> for IntegerWalker<T, E>

+where

+ T: Integer,

+ E: Environment,

+ Dynamic<T>: DynBind<E>,

+ Dynamic<OwnedStatic<i8>>: DynBind<E>,

+ Dynamic<OwnedStatic<i16>>: DynBind<E>,

+ Dynamic<OwnedStatic<i32>>: DynBind<E>,

+ Dynamic<OwnedStatic<i64>>: DynBind<E>,

+ Dynamic<OwnedStatic<i128>>: DynBind<E>,

+ Dynamic<OwnedStatic<isize>>: DynBind<E>,

+ Dynamic<OwnedStatic<u8>>: DynBind<E>,

+ Dynamic<OwnedStatic<u16>>: DynBind<E>,

+ Dynamic<OwnedStatic<u32>>: DynBind<E>,

+ Dynamic<OwnedStatic<u64>>: DynBind<E>,

+ Dynamic<OwnedStatic<u128>>: DynBind<E>,

+ Dynamic<OwnedStatic<usize>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<i8>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<i16>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<i32>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<i64>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<i128>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<isize>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<u8>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<u16>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<u32>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<u64>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<u128>>: DynBind<E>,

+ for<'a> Dynamic<&'a OwnedStatic<usize>>: DynBind<E>,

+{

+// any_trait! {

+// impl['ctx, T][E] IntegerWalker<T, E> = [

+// HintProto<ValueProto<OwnedStatic<i8>, E>>,

+// HintProto<ValueProto<OwnedStatic<i16>, E>>,

+// HintProto<ValueProto<OwnedStatic<i32>, E>>,

+// HintProto<ValueProto<OwnedStatic<i64>, E>>,

+// HintProto<ValueProto<OwnedStatic<i128>, E>>,

+// HintProto<ValueProto<OwnedStatic<u8>, E>>,

+// HintProto<ValueProto<OwnedStatic<u16>, E>>,

+// HintProto<ValueProto<OwnedStatic<u32>, E>>,

+// HintProto<ValueProto<OwnedStatic<u64>, E>>,

+// HintProto<ValueProto<OwnedStatic<u128>, E>>,

+// ] where

+// }

+

+ $(impl<'ctx, T: Integer, E: Environment> Hint<'ctx, type_name::Raised<'static, 'ctx, dyn Value<'ctx, OwnedStatic<$type>, E>>>

+ visitor: DynVisitorWith<'visitor, 'ctx, type_name::Raised<'static, 'ctx, dyn Value<'ctx, OwnedStatic<$type>, E>>>,

+ _hint: (),

+ _hint: &'a (),

+ ) -> NativeForm<'a, Result<ValueKnown<'a, OwnedStatic<$type>>, ()>, E>

+ where

+ ValueKnown<'a, OwnedStatic<$type>>: DynBind<E>

+ Flow, Never,

+use crate::{protocol::DynVisitor, Never};

+ bound::Dynamic,

+ higher_ranked::{for_lt, Rank1, WithLt},

+ any::{type_name, AnyTrait, BorrowedStatic, OwnedStatic},

+ Recoverable, RecoverableScope, Sequence, SequenceHint, SequenceKnown, SequenceScope,

+ Tag, TagConst, TagDyn, TagError, TagHint, TagKnown, Value, ValueKnown, VisitResult,

+ walker::hint::{DynVisitorWith, Hint, HintMeta},

+ walk::DynWalkerAdapter,

+ Flow, Never, Status,

+ Self: AnyTrait<'ctx> + RecoverableScope<'ctx, E>,

+pub enum StaticType {}

+impl<'ctx, I, M, E> AnyTrait<'ctx> for StructWalker<'ctx, I, StaticType, M, E>

+ I: StructTypeInfo<'ctx, M, E, S = StaticType>,

+ M: 'ctx,

+ I::T: 'static,

+ Dynamic<&'ctx I::T>: DynBind<E>,

+ Dynamic<BorrowedStatic<'ctx, I::T>>: DynBind<E>,

+ for<'a, 'b> Dynamic<&'a BorrowedStatic<'b, I::T>>: DynBind<E>,

+ Dynamic<TypeId>: DynBind<E>,

+ Dynamic<OwnedStatic<TypeId>>: DynBind<E>,

+// any_trait! {

+// impl['ctx, I, M][E] StructWalker<'ctx, I, StaticType, M, E> = [

+// HintProto<RecoverableProto<E>>,

+// HintProto<SequenceProto<E>>,

+// HintProto<ValueProto<BorrowedStaticHrt<I::T>, E>>,

+// HintProto<TagProto<TagDyn, E>>,

+// HintProto<TagProto<tags::TypeId, E>>,

+// HintProto<TagProto<tags::Struct, E>>,

+// HintProto<TagProto<tags::Map, E>>,

+// HintProto<TagProto<tags::TypeName, E>>,

+// HintProto<TagProto<tags::FieldNames, E>>,

+// ] where

+// }

+

+impl<'ctx, I, S, M, E> Hint<'ctx, type_name::Raised<'static, 'ctx, dyn Recoverable<'ctx, E>>>

+ Self: AnyTrait<'ctx> + RecoverableScope<'ctx, E>,

+ type_name::Raised<'static, 'ctx, dyn Recoverable<'ctx, E>>,

+ _hint: (),

+ // visit_recoverable::<E>(visitor, self),

+ // VisitResult::Skipped(_) => Flow::Continue,

+ // VisitResult::Control(flow) => flow,

+ hint: &'a WithLt<'a, Rank1<()>>,

+ ) -> NativeForm<'a, Result<WithLt<'a, Rank1<()>>, ()>, E>

+ WithLt<'a, Rank1<()>>: DynBind<E>,

+ E::value(Ok(())).cast()

+// impl<'c, 'ctx: 'c, I, S, M, E> Hint<'ctx, dyn Tag<'ctx, tags::FieldNames, E> + 'c>

+// for StructWalker<'ctx, I, S, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = S>,

+// {

+// #[inline(always)]

+// fn hint<'this, 'visitor, 'hint, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<

+// 'visitor,

+// 'ctx,

+// dyn Tag<'ctx, tags::FieldNames, E> + 'c,

+// >,

+// _hint: TagHint<tags::FieldNames>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // E::map(

+// // visit_tag::<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E, _>(

+// // TagConst,

+// // visitor,

+// // StaticSliceWalker::<_, ValueWalker<&'static str>>::new(I::FIELDS),

+// // ),

+// // |status| match status {

+// // Err(err) => {

+// // self.error = Some(StructWalkErrorKind::FieldTag(err));

+// // Flow::Err

+// // }

+// // Ok(VisitResult::Skipped(_)) => Flow::Continue,

+// // Ok(VisitResult::Control(flow)) => flow,

+// // },

+// // )

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(TagKnown {

+// kind_available: Some(true),

+// }))

+// .cast()

+// }

+// }

+//

+// impl<'c, 'ctx: 'c, I, S, M, E> Hint<'ctx, dyn Tag<'ctx, tags::TypeName, E> + 'c>

+// for StructWalker<'ctx, I, S, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = S>,

+// {

+// #[inline(always)]

+// fn hint<'this, 'visitor, 'hint, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Tag<'ctx, tags::TypeName, E> + 'c>,

+// _hint: TagHint<tags::TypeName>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // E::map(

+// // visit_tag::<TagConst<{ TAG_TYPE_NAME.to_int() }>, E, _>(

+// // TagConst,

+// // visitor,

+// // ValueWalker::new(I::NAME),

+// // ),

+// // |status| match status {

+// // Err(err) => {

+// // self.error = Some(StructWalkErrorKind::Tag(err));

+// // Flow::Err

+// // }

+// // Ok(VisitResult::Skipped(_)) => Flow::Continue,

+// // Ok(VisitResult::Control(flow)) => flow,

+// // },

+// // )

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(TagKnown {

+// kind_available: Some(true),

+// }))

+// .cast()

+// }

+// }

+//

+// impl<'c, 'ctx: 'c, I, S, M, E> Hint<'ctx, dyn Tag<'ctx, tags::Map, E> + 'c>

+// for StructWalker<'ctx, I, S, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = S>,

+// {

+// #[inline(always)]

+// fn hint<'this, 'visitor, 'hint, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Tag<'ctx, tags::Map, E> + 'c>,

+// _hint: TagHint<tags::Map>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // E::map(

+// // visit_tag::<TagConst<{ TAG_MAP.to_int() }>, E, _>(TagConst, visitor, NoopWalker::new()),

+// // |status| match status {

+// // Err(err) => {

+// // self.error = Some(StructWalkErrorKind::Tag(err));

+// // Flow::Err

+// // }

+// // Ok(VisitResult::Skipped(_)) => Flow::Continue,

+// // Ok(VisitResult::Control(flow)) => flow,

+// // },

+// // )

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(TagKnown {

+// kind_available: Some(true),

+// }))

+// .cast()

+// }

+// }

+//

+// impl<'c, 'ctx: 'c, I, S, M, E> Hint<'ctx, dyn Tag<'ctx, tags::Struct, E> + 'c>

+// for StructWalker<'ctx, I, S, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = S>,

+// {

+// #[inline(always)]

+// fn hint<'this: 'e, 'visitor: 'e, 'hint: 'e, 'e>(

+// &'this mut self,

+// visitor: DynVisitorWith<'visitor, 'ctx, dyn Tag<'ctx, tags::Struct, E> + 'c>,

+// _hint: TagHint<tags::Struct>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// E::with(

+// (visitor, DynWalkerAdapter::new(NoopWalker::new())),

+// |(visitor, noop_walker)| {

+// visitor

+// .as_known()

+// .visit(TagConst, noop_walker)

+// .map((), |_, status| {

+// VisitResult::Control(status.to_flow().unwrap_or(Flow::Continue))

+// })

+// .cast()

+// },

+// )

+// .map((), |_, (_, x)| x)

+// .cast()

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(TagKnown {

+// kind_available: Some(true),

+// }))

+// .cast()

+// }

+// }

+//

+// impl<'c, 'ctx: 'c, I, M, E> Hint<'ctx, dyn Tag<'ctx, tags::TypeId, E> + 'c>

+// for StructWalker<'ctx, I, StaticType, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = StaticType>,

+// I::T: 'static,

+// {

+// #[inline(always)]

+// fn hint<'this, 'visitor, 'hint, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Tag<'ctx, tags::TypeId, E> + 'c>,

+// _hint: TagHint<tags::TypeId>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // E::map(

+// // visit_tag::<TagConst<{ TAG_TYPE_ID.to_int() }>, E, _>(

+// // TagConst,

+// // visitor,

+// // ValueWalker::new(TypeId::of::<I::T>()),

+// // ),

+// // |status| match status {

+// // Err(err) => {

+// // self.error = Some(StructWalkErrorKind::Tag(err));

+// // Flow::Err

+// // }

+// // Ok(VisitResult::Skipped(_)) => Flow::Continue,

+// // Ok(VisitResult::Control(flow)) => flow,

+// // },

+// // )

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(TagKnown {

+// kind_available: Some(true),

+// }))

+// .cast()

+// }

+// }

+//

+// impl<'c, 'ctx: 'c, I, M, E> Hint<'ctx, dyn Tag<'ctx, TagDyn, E> + 'c> for StructWalker<'ctx, I, StaticType, M, E>

+// where

+// Self: DynBind<E>,

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = StaticType>,

+// I::T: 'static,

+// {

+// #[inline(always)]

+// fn hint<'this: 'e, 'visitor: 'e, 'hint: 'e, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Tag<'ctx, TagDyn, E> + 'c>,

+// _hint: TagHint<TagDyn>,

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // match hint.kind.0 {

+// // crate::TAG_TYPE_ID => {

+// // Hint::<'ctx, TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E>>::hint(

+// // self,

+// // visitor,

+// // TagHint { kind: TagConst },

+// // )

+// // }

+// // crate::TAG_STRUCT => {

+// // Hint::<'ctx, TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E>>::hint(

+// // self,

+// // visitor,

+// // TagHint { kind: TagConst },

+// // )

+// // }

+// // crate::TAG_MAP => Hint::<'ctx, TagProto<TagConst<{ TAG_MAP.to_int() }>, E>>::hint(

+// // self,

+// // visitor,

+// // TagHint { kind: TagConst },

+// // ),

+// // crate::TAG_TYPE_NAME => {

+// // Hint::<'ctx, TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>::hint(

+// // self,

+// // visitor,

+// // TagHint { kind: TagConst },

+// // )

+// // }

+// // crate::TAG_FIELD_NAMES => Hint::<

+// // 'ctx,

+// // TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>,

+// // >::hint(self, visitor, TagHint { kind: TagConst }),

+// // _ => E::ready(Flow::Continue),

+// // }

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<TagHint<TagDyn>>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<TagKnown>>: DynBind<Protocol::Env>

+// {

+// E::value(match hint.kind {

+// TagDyn(tags::TypeId::VALUE) | TagDyn(tags::Struct::VALUE) => Ok(TagKnown {

+// kind_available: Some(true),

+// }),

+// _ => Ok(TagKnown {

+// kind_available: Some(false),

+// }),

+// })

+// .cast()

+// }

+// }

+//

+// impl<'x, 'ctx: 'x, I, M, E> Hint<'ctx, dyn Value<'ctx, BorrowedStatic<'ctx, I::T>, E> + 'x>

+// for StructWalker<'ctx, I, StaticType, M, E>

+// where

+// E: Environment,

+// I: StructTypeInfo<'ctx, M, E, S = StaticType>,

+// I::T: 'static,

+// for<'a, 'b> Dynamic<&'a BorrowedStatic<'b, I::T>>: DynBind<E>,

+// Dynamic<&'ctx I::T>: DynBind<E>,

+// {

+// #[inline(always)]

+// fn hint<'this, 'visitor, 'hint, 'e>(

+// &'this mut self,

+// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Value<'ctx, BorrowedStatic<'ctx, I::T>, E> + 'x>,

+// _hint: (),

+// ) -> NativeForm<'e, VisitResult, E>

+// where

+// 'ctx: 'this + 'visitor + 'hint + 'e,

+// {

+// todo!()

+// // E::map(

+// // visit_value::<_, E>(visitor, BorrowedStatic(self.value)),

+// // |status| match status {

+// // VisitResult::Skipped(_) => Flow::Continue,

+// // VisitResult::Control(flow) => flow,

+// // },

+// // )

+// }

+//

+// #[inline(always)]

+// fn known<'a>(

+// &'a mut self,

+// hint: &'a WithLt<'a, Rank1<()>>,

+// ) -> NativeForm<'a, Result<WithLt<'a, Rank1<ValueKnown<'a, BorrowedStatic<'ctx, I::T>>>>, ()>, Protocol::Env>

+// where

+// WithLt<'a, Rank1<ValueKnown<'a, BorrowedStatic<'ctx, I::T>>>>: DynBind<Protocol::Env>

+// {

+// E::value(Ok(ValueKnown { preview: None })).cast()

+// }

+// }

+

+impl<'ctx, I, S, M: 'ctx, E> Hint<'ctx, type_name::Raised<'static, 'ctx, dyn Sequence<'ctx, E>>>

+ visitor: DynVisitorWith<

+ 'visitor,

+ 'ctx,

+ type_name::Raised<'static, 'ctx, dyn Sequence<'ctx, E>>,

+ >,

+ _hint: SequenceHint,

+ hint: &'a WithLt<'a, Rank1<SequenceHint>>,

+ ) -> NativeForm<'a, Result<WithLt<'a, Rank1<SequenceKnown>>, ()>, E>

+ where

+ WithLt<'a, Rank1<SequenceKnown>>: DynBind<E>,

+ {

+ visit_tag::<tags::TypeId, E, _>(

+ visit_tag::<tags::Struct, E, _>(TagConst, visitor.cast(), NoopWalker::new())

+ .map(this, |this, result| {

+ this.record_tag_error(result).unit_skipped()

+ })

+ .cast()

+ visit_tag::<tags::Map, E, _>(TagConst, visitor.cast(), NoopWalker::new())

+ .map(this, |this, result| {

+ this.record_tag_error(result).unit_skipped()

+ })

+ .cast()

+ any::AnyTrait,

+ Flow, Never,

+impl<'ctx, T, W> AnyTrait<'ctx> for StaticSliceWalker<T, W> {}

+

+// any_trait! {

+// impl['a, 'ctx, T, W][E] StaticSliceWalker<T, W> = [

+// ] where E: Environment, T: IsSync<E::NeedSend> + IsSync<E::NeedSync>

+// }

+ any::{BorrowedStatic, OwnedStatic, TempBorrowedStatic},

+ Never,

+use crate::walk::walkers::core::noop::NoopWalker;

+ bound::{Dynamic, No},

+ higher_ranked::{Rank1, WithLt},

+ any::{type_name, AnyTrait, BorrowedStatic, OwnedStatic, TempBorrowedStatic},

+ SequenceScope, Tag, TagConst, TagHint, TagKnown, Value, ValueKnown, VisitResult,

+ walker::hint::{DynVisitorWith, Hint, HintMeta},

+ walk::walkers::core::int::IntegerWalkerError,

+impl<'ctx, T, E> AnyTrait<'ctx> for DeserializerWalker<'ctx, T, E>

+where

+ T: Deserializer<'ctx>,

+ E: Environment<NeedSend = No, NeedSync = No>,

+{

+// any_trait! {

+// impl['ctx, T][E] DeserializerWalker<'ctx, T, E> = [

+// HintProto<ValueProto<OwnedStatic<bool>, E>>,

+// HintProto<ValueProto<OwnedStatic<i8>, E>>,

+// HintProto<ValueProto<OwnedStatic<i16>, E>>,

+// HintProto<ValueProto<OwnedStatic<i32>, E>>,

+// HintProto<ValueProto<OwnedStatic<i64>, E>>,

+// HintProto<ValueProto<OwnedStatic<i128>, E>>,

+// HintProto<ValueProto<OwnedStatic<u8>, E>>,

+// HintProto<ValueProto<OwnedStatic<u16>, E>>,

+// HintProto<ValueProto<OwnedStatic<u32>, E>>,

+// HintProto<ValueProto<OwnedStatic<u64>, E>>,

+// HintProto<ValueProto<OwnedStatic<u128>, E>>,

+// HintProto<ValueProto<OwnedStatic<char>, E>>,

+// HintProto<TagProto<tags::Map, E>>,

+// ] where

+// T: Deserializer<'ctx>,

+// E: Environment<NeedSend = No, NeedSync = No>

+// }

+

+ #[allow(clippy::type_complexity)]

+ $(impl<$ctx, $T, $E: Environment> Hint<$ctx, type_name::Raised<'static, $ctx, $proto>> for DeserializerWalker<$ctx, $T, $E>

+ visitor: DynVisitorWith<'visitor, $ctx, type_name::Raised<'static, $ctx, $proto>>,

+ _hint: WithLt<'hint, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Hint>,

+ _hint: &'a WithLt<'a, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Hint>,

+ ) -> NativeForm<'a, Result<WithLt<'a, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Known>, ()>, $E>

+ where

+ WithLt<'a, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Known>: DynBind<$E>

+ {

+ dyn Value<'ctx, OwnedStatic<bool>, E> => deserialize_bool: bool,

+ dyn Value<'ctx, OwnedStatic<i8>, E> => deserialize_i8: i8,

+ dyn Value<'ctx, OwnedStatic<i16>, E> => deserialize_i16: i16,

+ dyn Value<'ctx, OwnedStatic<i32>, E> => deserialize_i32: i32,

+ dyn Value<'ctx, OwnedStatic<i64>, E> => deserialize_i64: i64,

+ dyn Value<'ctx, OwnedStatic<i128>, E> => deserialize_i128: i128,

+ dyn Value<'ctx, OwnedStatic<u8>, E> => deserialize_u8: u8,

+ dyn Value<'ctx, OwnedStatic<u16>, E> => deserialize_u16: u16,

+ dyn Value<'ctx, OwnedStatic<u32>, E> => deserialize_u32: u32,

+ dyn Value<'ctx, OwnedStatic<u64>, E> => deserialize_u64: u64,

+ dyn Value<'ctx, OwnedStatic<u128>, E> => deserialize_u128: u128,

+ dyn Value<'ctx, OwnedStatic<f32>, E> => deserialize_f32: f32,

+ dyn Value<'ctx, OwnedStatic<f64>, E> => deserialize_f64: f64,

+ dyn Value<'ctx, OwnedStatic<char>, E> => deserialize_char: char,

+ dyn Value<'ctx, type_name::Raised<'static, 'ctx, TempBorrowedStatic<'static, str>>, E> => deserialize_str: &str,

+ dyn Value<'ctx, type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, str>>, E> => deserialize_str: &str,

+ dyn Value<'ctx, OwnedStatic<String>, E> => deserialize_string: String,

+ dyn Value<'ctx, type_name::Raised<'static, 'ctx, TempBorrowedStatic<'static, [u8]>>, E> => deserialize_bytes: &[u8],

+ dyn Value<'ctx, type_name::Raised<'static, 'ctx, BorrowedStatic<'ctx, [u8]>>, E> => deserialize_bytes: &[u8],

+ dyn Value<'ctx, OwnedStatic<Vec<u8>>, E> => deserialize_byte_buf: Vec<u8>,

+impl<'ctx, T, E: Environment>

+ Hint<'ctx, type_name::Raised<'static, 'ctx, dyn Tag<'ctx, tags::Map, E>>>

+ for DeserializerWalker<'ctx, T, E>

+ _visitor: DynVisitorWith<

+ 'visitor,

+ 'ctx,

+ type_name::Raised<'static, 'ctx, dyn Tag<'ctx, tags::Map, E>>,

+ >,

+ _hint: TagHint<tags::Map>,

+ ) -> NativeForm<'e, VisitResult, E>

+ _hint: &'a WithLt<'a, Rank1<TagHint<tags::Map>>>,

+ ) -> NativeForm<'a, Result<WithLt<'a, Rank1<TagKnown>>, ()>, E>

+ where

+ WithLt<'a, Rank1<TagKnown>>: DynBind<E>,

+ {

+ Ok($crate::walk::walkers::core::int::IntegerWalker::<_, E>::new(v).walk(self.visitor).map((), |_, result| match result {

+ formatter.write_str(self.wanted)

+ fn visit_str<Err>(self, _v: &str) -> Result<Self::Value, Err>

+ where

+ Err: serde::de::Error,

+ {

+ todo!()

+ }

+

+ let _x = self.map.0.next_value_seed(ValueDeserialize { visitor });

+ let _x = visit_tag::<tags::Key, E, _>(TagConst, self.visitor.cast(), walker)

+ let _x = walker.walk(self.visitor).wait();

+ // dbg!(x);

+ any::{type_name, OwnedStatic},

+ build::BuilderTypes,

+ transform::BuildExt as _,

+ walk::walkers::core::value::{BorrowWalker, ValueWalker},

+ Build, Builder, Status,

+ builder.visit_tag_and_done::<tags::Variant, _>(ValueWalker::new(0u32));

+ builder.visit_tag_and_done::<tags::Variant, _>(BorrowWalker::new("A"));

+ transform::BuildExt as _,

+ walk::walkers::core::noop::NoopWalker,

+ Build, Builder, Flow,

+ any::{type_name, BorrowedStatic, OwnedStatic, TempBorrowedStatic},

+ visitor::{request_hint, Value},

+ transform::BuildExt as _,

+ Builder as _, Flow,

+ let mut walker = MockHintWalker::<

+ type_name::Raised<'_, '_, dyn Value<'_, OwnedStatic<i32>, Blocking>>,

+ >::new();

+ any::{AnyTrait, MutAnyUnsized, WithLtTypeId},

+ build::BuilderTypes,

+ Builder,

+ // pub fn traits(&self, id: WithLtTypeId<'_, '_>) -> &Option<Box<DynamicShim<dyn for<'ctx> AnyTrait<'ctx, E>>>>;

+ // pub fn traits_mut(&mut self, id: WithLtTypeId<'_, '_>) -> &mut Option<Box<DynamicShim<dyn for<'ctx> AnyTrait<'ctx, E>>>>;

+

+ pub fn traits_mut(&mut self) -> &mut Box<dyn for<'a, 'ctx> FnMut(WithLtTypeId<'a, 'ctx>) -> Option<MutAnyUnsized<'a, 'a, 'ctx>>>;

+impl<'ctx, Seed, Value, Error, E: Environment> AnyTrait<'ctx> for MockBuilder<Seed, Value, Error, E>

+ fn upcast_by_id<'a, 'lt: 'a>(

+ id: treaty::any::WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<treaty::any::RefAnyUnsized<'a, 'lt, 'ctx>>

+ 'ctx: 'lt,

+ let _id = id;

+ None

+ fn upcast_by_id_mut<'a, 'lt: 'a>(

+ id: treaty::any::WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<treaty::any::MutAnyUnsized<'a, 'lt, 'ctx>>

+ 'ctx: 'lt,

+ self.traits_mut()(id)

+ // fn upcast_to_id<'a>(

+ // &'a self,

+ // id: TypeNameId,

+ // ) -> Option<AnyTraitObject<'a, 'ctx, indirect::Ref, E>>

+ // where

+ // 'ctx: 'a,

+ // {

+ // // Find the first trait handler that wants to upcast.

+ // self.traits(id).as_ref().and_then(|t| t.0.upcast_to_id(id))

+ // }

+ //

+ // fn upcast_to_id_mut<'a>(

+ // &'a mut self,

+ // id: TypeNameId,

+ // ) -> Option<AnyTraitObject<'a, 'ctx, indirect::Mut, E>>

+ // where

+ // 'ctx: 'a,

+ // {

+ // // Find the first trait handler that wants to upcast.

+ // self.traits_mut(id)

+ // .as_mut()

+ // .and_then(|t| t.0.upcast_to_id_mut(id))

+ // }

+ //

+ // type Available = () where Self: Sized;

+#![allow(clippy::type_complexity)]

+ higher_ranked::WithLt,

+ any::{type_name, AnyTrait, MutAnyUnsized, WithLtTypeId, trait_by_id},

+ walker::hint::{DynVisitorWith, Hint, HintMeta},

+pub type KnownFactory<P> = for<'a, 'ctx> fn(

+ &'ctx (),

+ &'a WithLt<'a, <P as HintMeta>::Hint>,

+) -> Result<WithLt<'a, <P as HintMeta>::Known>, ()>;

+ pub HintWalker<P: ?Sized + HintMeta> {

+ pub fn hint<'a, 'b, 'c, 'ctx>(&'a mut self, visitor: DynVisitorWith<'b, 'ctx, P>, hint: WithLt<'c, P::Hint>) -> VisitResult;

+forward_send_sync!({} {} {P: (?Sized + HintMeta)} MockHintWalker<P>);

+impl<'ctx, P: ?Sized + HintMeta> AnyTrait<'ctx> for MockHintWalker<P> {

+ fn upcast_by_id_mut<'a, 'lt: 'a>(

+ &'a mut self,

+ id: WithLtTypeId<'lt, 'ctx>,

+ ) -> Option<MutAnyUnsized<'a, 'lt, 'ctx>>

+ where

+ 'ctx: 'lt,

+ {

+ trait_by_id!(&mut self, id, {

+ type Impls<'lt, 'ctx> = (dyn Hint<P>);

+

+ None

+ })

+ }

+// any_trait! {

+// impl['ctx, P][E] MockHintWalker<P> = [

+// HintProto<P>

+// ] where

+// E: Environment,

+// P: HintMeta<Effect = E>,

+// }

+

+impl<'ctx, P: ?Sized + HintMeta> Hint<'ctx, P> for MockHintWalker<P> {

+ fn hint<'this: 'e, 'visitor: 'e, 'hint: 'e, 'e>(

+ hint: WithLt<'hint, <P as HintMeta>::Hint>,

+ ) -> NativeForm<'e, VisitResult, <P>::Env>

+ 'ctx: 'this + 'visitor + 'hint,

+ P::Env::value(self.hint(visitor, hint)).cast()

+ hint: &'a WithLt<'a, <P as HintMeta>::Hint>,

+ ) -> NativeForm<'a, Result<WithLt<'a, <P as HintMeta>::Known>, ()>, <P>::Env>

+ where

+ WithLt<'a, <P as HintMeta>::Known>: effectful::environment::DynBind<<P>::Env>,

+ {

+ todo!()

+

+ // fn hint<'this, 'visitor, 'hint, 'e>(

+ // &'this mut self,

+ // visitor: DynVisitorWith<'visitor, 'ctx, P>,

+ // hint: WithLt<'hint, P>,

+ // ) -> NativeForm<'e, VisitResult, P::Effect>

+ // where

+ // 'ctx: 'this + 'visitor + 'hint + 'e,

+ // {

+ // P::Effect::value(self.hint(visitor, hint)).cast()

+ // }

+ //

+ // fn known<'a>(

+ // &'a mut self,

+ // hint: &'a WithLt<'a, P::Hint>,

+ // ) -> NativeForm<'a, Result<WithLt<'a, P::Known>, ()>, P::Effect> {

+ // P::Effect::value(Self::known(self)(&(), hint)).cast()

+ // }

+ any::{type_name, AnyTrait},

+ RecoverableScope, RequestHint, Sequence, SequenceScope, Value, VisitResult,

+// any_trait! {

+// impl['ctx][E] MockRecoverableVisitor<E> = [

+// RecoverableProto<E>

+// ] where

+// E: Environment,

+// }

+ any::{type_name, AnyTrait},

+ protocol::visitor::{RequestHint, Value, VisitResult},

+// any_trait! {

+// impl['ctx][E] MockRequestHintVisitor<E> = [

+// RequestHintProto<E>

+// ] where

+// E: Environment,

+// }

+ any::{type_name, AnyTrait},

+ visitor::{DynSequenceScope, RequestHint, Sequence, SequenceScope, Value, VisitResult},

+// any_trait! {

+// impl['ctx][E] MockSequenceVisitor<E> = [

+// SequenceProto<E>

+// ] where

+// E: Environment,

+// }

+ any::AnyTrait,

+ visitor::{visit_tag, ConstTagKind, Tag, TagConst, TagKind, VisitResult},

+ walk::DynWalkerObjSafe,

+ Flow, Walker,

+// any_trait! {

+// impl['ctx, K][E] MockTagVisitor<K, E> = [

+// TagProto<K, E>,

+// ] where

+// K: TagKind<E>,

+// E: Environment,

+// }

+ fn visit_tag_and_done<'a, T: ConstTagKind<Blocking>, W: Walker<'ctx, Blocking>>(

+ &'a mut self,

+ walker: W,

+ );

+ fn visit_tag_and_done<'a, Tag: ConstTagKind<Blocking>, W: Walker<'ctx, Blocking>>(

+ &'a mut self,

+ walker: W,

+ ) {

+ let result =

+ visit_tag::<Tag, Blocking, _>(Tag::NEW, self.as_visitor(), walker).into_value();

+ any::{type_name, AnyTrait, OwnedStatic},

+ visitor::{visit_value, Value, VisitResult},

+ pub ValueVisitor<T: type_name::Static>

+ for<'a, 'ctx> type_name::Lowered<'a, 'ctx, T>: Sized

+ pub fn visit<'a, 'ctx>(&'a mut self, value: &type_name::Lowered<'a, 'ctx, T>) -> VisitResult<()>;

+forward_send_sync!({} {} {T: (type_name::Static)} MockValueVisitor<T> where {

+ for<'a, 'ctx> type_name::Lowered<'a, 'ctx, T>: Sized

+// any_trait! {

+// impl['ctx, T][E] MockValueVisitor<T, E> = [

+// ValueProto<T, E>

+// ] where

+// T: TypeName::MemberType<E>,

+// for<'a, 'b> TypeName::T<'a, 'b, T, E>: Sized,

+// for<'a> Dynamic<TypeName::T<'a, 'ctx, T, E>>: DynBind<E>,

+// E: Environment,

+// }

+impl<'ctx, T: type_name::Static, E: Environment> Value<'ctx, T, E> for MockValueVisitor<T>

+ for<'a, 'b> type_name::Lowered<'a, 'b, T>: Sized,

+ fn visit<'this: 'value, 'value: 'e, 'e>(

+ &'this mut self,

+ value: type_name::Lowered<'value, 'ctx, T>,

+ ) -> NativeForm<'e, VisitResult<Dynamic<type_name::Lowered<'value, 'ctx, T>>>, E>

+ // type_name::Lowered<'value, 'ctx, T>: Sized,

+ Dynamic<type_name::Lowered<'value, 'ctx, T>>: DynBind<E>,

+ 'ctx: 'this + 'value,

+ todo!()

+

+ // fn visit<'a>(

+ // &'a mut self,

+ // value: TypeName::T<'a, 'ctx, T, E>,

+ // ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, T, E>>>, E>

+ // where

+ // 'ctx: 'a,

+ // {

+ // E::value(match self.visit(&value) {

+ // VisitResult::Skipped(_) => VisitResult::Skipped(Dynamic(value)),

+ // VisitResult::Control(flow) => VisitResult::Control(flow),

+ // })

+ // .cast()

+ // }

+ T: type_name::WithLt<'a, 'ctx>,

+ type_name::Raised<'a, 'ctx, T>: type_name::Static,

+ T: type_name::WithLt<'a, 'ctx>,

+ type_name::Raised<'a, 'ctx, T>: type_name::Static,

+ T: type_name::WithLt<'a, 'ctx>,

+ type_name::Raised<'a, 'ctx, T>: type_name::Static,

+ T: type_name::WithLt<'a, 'ctx>,

+ type_name::Raised<'a, 'ctx, T>: type_name::Static,

+ todo!()

+

+ // #[track_caller]

+ // fn visit_value_and_done<'a, T>(&'a mut self, value: T)

+ // where

+ // T: TypeName::LowerType<'a, 'ctx, Blocking>,

+ // TypeName::HigherRanked<'a, 'ctx, T, Blocking>: TypeName::MemberType<Blocking>,

+ // 'ctx: 'a,

+ // {

+ // let result = visit_value::<_, Blocking>(self.as_visitor(), value).into_value();

+ //

+ // assert_eq!(result, VisitResult::Control(Flow::Done));

+ // }

+ //

+ // #[track_caller]

+ // fn visit_value_and_skipped<'a, T>(&'a mut self, value: T)

+ // where

+ // T: TypeName::LowerType<'a, 'ctx, Blocking>,

+ // TypeName::HigherRanked<'a, 'ctx, T, Blocking>: TypeName::MemberType<Blocking>,

+ // 'ctx: 'a,

+ // {

+ // let result = visit_value::<_, Blocking>(self.as_visitor(), value).into_value();

+ //

+ // assert_eq!(result.unit_skipped(), VisitResult::Skipped(()));

+ // }

+use treaty::{any::AnyTrait, build::BuilderTypes, protocol::DynVisitor, Builder, Walker};

+ // pub fn traits(&self, id: TypeNameId) -> &Option<Box<dyn for<'ctx> AnyTrait<'ctx, E>>>;

+ //

+ // pub fn traits_mut(&mut self, id: TypeNameId) -> &mut Option<Box<dyn for<'ctx> AnyTrait<'ctx, E>>>;

+impl<'ctx, Output: DynBind<E>, Error: DynBind<E>, E: Environment> AnyTrait<'ctx>

+ // fn upcast_to_id<'a>(

+ // &'a self,

+ // id: TypeNameId,

+ // ) -> Option<AnyTraitObject<'a, 'ctx, indirect::Ref, E>>

+ // where

+ // 'ctx: 'a,

+ // {

+ // self.traits(id).as_ref().and_then(|t| t.upcast_to_id(id))

+ // }

+ //

+ // fn upcast_to_id_mut<'a>(

+ // &'a mut self,

+ // id: TypeNameId,

+ // ) -> Option<AnyTraitObject<'a, 'ctx, indirect::Mut, E>>

+ // where

+ // 'ctx: 'a,

+ // {

+ // self.traits_mut(id)

+ // .as_mut()

+ // .and_then(|t| t.upcast_to_id_mut(id))

+ // }

+ //

+ // type Available = () where Self: Sized;

+ visitor::{Recoverable, VisitResult},

+ any::OwnedStatic,

+ visitor::{RequestHint, ValueKnown, VisitResult},

+ any::OwnedStatic,

+ visitor::{Sequence, VisitResult},

+ any::OwnedStatic,

+ visitor::{Tag, TagConst, TagDyn, VisitResult},

+ walk::DynWalkerAdapter,

+ Flow,

+ any::{AnyTrait, BorrowedStatic, OwnedStatic, TempBorrowedMutStatic},

+ visitor::{visit_value, Value, ValueKnown, VisitResult},

+use treaty::protocol::walker::hint::{self, HintMeta};

+use treaty::walk::walkers::serde::deserializer::DeserializerWalker;

+use treaty::{transform::BuildExt as _, Build};

+ any::{BorrowedStatic, OwnedStatic},

+ visitor::{tags, TagConst, VisitResult},

+ walk::walkers::core::r#struct::{StructTypeInfo, StructWalker},

+ DefaultMode, Flow, Walker,