checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]

name = "downcast"

version = "0.11.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"

[[package]]

name = "errno"

version = "0.3.8"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

"cfg-if",

"proc-macro2",

"quote",

]

[[package]]

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

]

[[package]]

name = "proc-macro2"

version = "1.0.76"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"

[[package]]

name = "rustix"

version = "0.38.30"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

[[package]]

name = "syn"

version = "2.0.48"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

name = "treaty"

version = "0.0.1"

dependencies = [

"futures",

"macro_rules_attribute",

"mockall",

checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

[[package]]

name = "wait-timeout"

version = "0.2.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

futures = "0.3.30"

pin-project = "1.1.5"

serde = { version = "1.0", optional = true }

[features]

default = ["std", "serde"]

use crate::hkt::{Invariant, Marker};

use core::marker::PhantomData;

pub use static_wrapper::*;

pub use type_name_id::*;

#[allow(non_snake_case)]

pub mod TypeName {

}

{

}

}

{

}

}

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

where

{

}

where

{

}

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

where

{

}

where

{

}

#[cfg(feature = "alloc")]

where

{

}

#[cfg(feature = "alloc")]

where

{

}

/// Dynamic trait lookup.

// impl['ctx] MyNum = [DynToNum]

// }

// ```

/// The trait objects this type can be upcasted to.

type Available

where

fn upcast_to_id<'a>(

&'a self,

id: TypeNameId,

where

'ctx: 'a;

fn upcast_to_id_mut<'a>(

&'a mut self,

id: TypeNameId,

where

'ctx: 'a;

}

/// Upcast a borrow to the given trait object type.

///

/// This should be used instead of [`upcast_to_id`][AnyTrait::upcast_to_id]

///

/// If the returned [`AnyTraitObject`] is the wrong type, then a panic happens.

#[inline(always)]

&'a self,

.map(|object| match object.downcast() {

Ok(object) => object,

Err(object) => panic!(

"Unexpected trait object. This means a bad impl of \

`upcast_to_id`. Expected: {:?}, Got {:?}",

object.id()

),

})

///

/// If the returned [`AnyTraitObject`] is the wrong type, then a panic happens.

#[inline(always)]

&'a mut self,

.map(|object| match object.downcast() {

Ok(object) => object,

Err(object) => panic!(

"Unexpected trait object. This means a bad impl of \

`upcast_to_id_mut`. Expected: {:?}, Got {:?}",

object.id()

),

})

#[macro_export]

macro_rules! any_trait {

{

ref {

let ($if_this:ident, $if_id:ident);

$($if_fallback:tt)*

}

$(where $($bound:tt)*)?

} => {

$(where $($bound)*)?

{

type Available = (

fn upcast_to_id<'__>(

&'__ self,

id: $crate::any::TypeNameId

where

$lt: '__

{

// This match should be optimized well by llvm.

match $if_id {

>($if_this as _)),)*

_ => {

$($fallback)*

fn upcast_to_id_mut<'__>(

&'__ mut self,

id: $crate::any::TypeNameId

where

$lt: '__

{

// This match should be optimized well by llvm.

match $if_mut_id {

>($if_mut_this as _)),)*

_ => {

$($mut_fallback)*

}

};

{

$(where $($bound:tt)*)?

} => {

$crate::any::any_trait! {

ref {

let (_this, _id);

} else ref {

///

/// The `I` generic is the flavor if pointer being used. It can be [`Ref`][indirect::Ref] or [`Mut`][indirect::Mut].

#[must_use]

/// The extra vtable pointer.

///

/// The TypeNameId gives the TypeId of the T's type name.

_lifetime: Invariant<'ctx>,

_not_send_sync: PhantomData<*const ()>,

}

/// Type erase a pointer.

///

/// `T` doesn't need to be [`Sized`]. As such, a fat pointer can be passed to this function.

Self {

indirect: RawIndirect::new(indirect),

_lifetime: Default::default(),

_not_send_sync: PhantomData,

}

}

///

/// If the type of the stored value is different, then `self` is

/// returned as is.

// SAFETY: We know that the type name type is unique per T because it is bijective.

// A self is only made in Self::new where the info is taken from T.

// If the check above passes then we know T must be the same minus the lifetimes.

//! Wrapper types that impl [`TypeName`] when their generic type `T` is `'static`.

use crate::hkt::Marker;

use super::*;

#[repr(transparent)]

pub struct OwnedStatic<T: ?Sized>(pub T);

where

{

type T = OwnedStatic<T>;

}

where

{

type Higher = OwnedStatic<T>;

}

#[repr(transparent)]

pub struct BorrowedStatic<'ctx, T: ?Sized>(pub &'ctx T);

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

where

{

type T = BorrowedStatic<'ctx, T>;

}

for BorrowedStatic<'ctx, T>

where

{

type Higher = BorrowedStaticHrt<T>;

}

#[repr(transparent)]

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

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

for TempBorrowedStaticHrt<T>

where

{

type T = TempBorrowedStatic<'a, T>;

}

for TempBorrowedStatic<'a, T>

where

{

type Higher = TempBorrowedStaticHrt<T>;

}

#[repr(transparent)]

pub struct BorrowedMutStatic<'ctx, T: ?Sized>(pub &'ctx mut T);

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

for BorrowedMutStaticHrt<T>

where

{

type T = BorrowedMutStatic<'ctx, T>;

}

for BorrowedMutStatic<'ctx, T>

where

{

type Higher = BorrowedMutStaticHrt<T>;

}

#[repr(transparent)]

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

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

for TempBorrowedMutStaticHrt<T>

where

{

type T = TempBorrowedMutStatic<'a, T>;

}

for TempBorrowedMutStatic<'a, T>

where

{

type Higher = TempBorrowedMutStaticHrt<T>;

}

pub struct BoxedStatic<T: ?Sized>(pub Box<T>);

#[cfg(feature = "alloc")]

where

{

type T = BoxedStatic<T>;

}

#[cfg(feature = "alloc")]

where

{

type Higher = BoxedStatic<T>;

}

#[cfg(feature = "better_errors")]

use core::any::type_name;

use super::TypeName;

/// [`TypeId`] for the [`TypeName`] family of types.

impl TypeNameId {

/// Get the type ID from a [`TypeName::LowerType`] ([`WithContextLt`]) higher ranked type.

#[inline(always)]

Self {

name_id: TypeId::of::<T>(),

/// Get the type ID from a lower type.

#[inline(always)]

Self {

#[cfg(feature = "better_errors")]

name: type_name::<T>(),

/// Get the type ID of a lower type's value.

#[inline(always)]

}

/// Converts the type name ID to a normal [`TypeId`].

use core::fmt::{Debug, Display};

pub mod builders;

use crate::{

protocol::{AsVisitor, DynVisitor},

};

/// A buildable type.

/// The builder that can be used to build a value of `Self`.

type Builder: Builder<'ctx, E, Value = Self>;

}

/// Error that can happen during filling the builder with data.

/// Type to be built.

}

/// Builder for a type.

/// the builder with data from it's walk.

/// - Call [`Self::build()`] to finish building the value and get any errors

/// that happened during filling it with data.

where

Self: 'a;

///

/// If an error happened with the builder during the walk

/// it will be reported here.

where

Self: 'a;

}

use crate::{

any_trait,

protocol::{visitor::VisitResult, DynVisitor},

DynWalkerObjSafe,

};

#[non_exhaustive]

pub struct NoopVisitor;

impl NoopVisitor {

pub fn new() -> Self {

Self

}

any_trait! {

}

impl NoopVisitor {

walker: DynWalkerObjSafe<'walker, 'ctx, E>,

walker

.walk(DynVisitor(noop))

.map(|x| x.to_continue().into())

use super::value::{Cloneable, ValueBuilder};

macro_rules! value_builder {

[$($ty:ty),*] => {

type Builder = ValueBuilder<$ty, Cloneable, E>;

})*

};

use core::fmt::{Debug, Display};

use crate::any::{OwnedStatic, TempBorrowedStatic, TempBorrowedStaticHrt};

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

use crate::protocol::AsVisitor;

use crate::{

any::{AnyTraitObject, TypeName, TypeNameId},

any_trait,

hkt::Invariant,

protocol::{

visitor::{tags, Tag, TagProto, Value, ValueProto, VisitResult},

Builder, BuilderTypes, DynWalkerObjSafe, Flow,

};

where

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

{

inner: Inner<'ctx, Info, Mode, E>,

}

where

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

{

Value(Result<Info::T, Info::Error>),

}

fn new_builder<'a>(

seed: Self::Seed,

variant: Self::VariantMarker,

fn finish_builder<'a>(

builder: Self::Builders,

fn marker_from_name(name: &str) -> Option<Self::VariantMarker>;

fn guess_variant<'a>(

seed: Self::Seed,

scope: DynRecoverableScope<'a, 'ctx, E>,

}

where

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

{

type Value = Info::T;

}

where

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

{

where

Self: 'a,

{

inner: Inner::Seed(seed),

}

where

Self: 'a,

{

todo!()

}

Inner::Builder { builder } => Info::finish_builder(builder),

}

}

}

where

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

{

where

'ctx: 'a,

{

}

any_trait! {

ValueProto<Info::ValueT, E>,

TagProto<tags::Variant, E>,

RecoverableProto<E>

} else mut {

None

} where

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

}

where

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

{

fn visit<'a>(

&'a mut self,

scope: DynRecoverableScope<'a, 'ctx, E>,

match core::mem::replace(&mut self.inner, Inner::Temp) {

Flow::Done.into()

inner => {

self.inner = inner;

}

}

}

}

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

self.inner = Inner::Value(Ok(Info::from_value(value)));

}

}

where

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

{

&'a mut self,

_kind: tags::Variant,

walker: DynWalkerObjSafe<'b, 'ctx, E>,

let visitor = VariantVisitor::<Info, Mode, E> { marker: None };

walker.walk(DynVisitor(visitor)).cast()

if let Some(variant) = visitor.marker {

// A variant was given so we need to make the builder for

// it.

result.to_done().into()

inner => {

}

}

} else {

}

}

}

where

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

{

marker: Option<Info::VariantMarker>,

}

any_trait! {

ValueProto<TempBorrowedStaticHrt<str>, E>,

ValueProto<OwnedStatic<u32>, E>,

]

where

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

}

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

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

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

self.marker = Some(variant);

} else {

}

}

}

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

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

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

self.marker = Some(variant);

} else {

}

}

}

use core::fmt::{Debug, Display};

use crate::{

any::{OwnedStatic, TempBorrowedStatic, TempBorrowedStaticHrt, TypeName},

any_trait,

hkt::Marker,

protocol::{

visitor::{

walker::hint::hint_protocol,

AsVisitor, DynVisitor, DynWalker,

},

};

use super::NoopVisitor;

/// A builder for a struct.

where

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

{

inner: Inner<'ctx, Info, Mode, E>,

}

where

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

{

///

/// The `Mode` generic allows implementations to change depending on the mode the user gives.

/// It is not used by the trait directly.

/// A struct of builders for each field.

/// The seed value needed to make the builders.

/// An enum of the fields.

///

/// These markers act in place of the field names.

/// The error type that can be generated while building the struct.

/// The kind of type for enabling the direct value protocol.

/// The struct type this info is for.

const FIELD_COUNT: usize;

/// Create a set of builders from a seed value.

/// Finish building the struct value.

fn from_builders<'a>(

builders: Self::Builders,

/// Get the visitor for a field.

///

fn as_visitor<'a>(

marker: Self::FieldMarker,

builders: &'a mut Self::Builders,

/// Get a field marker from the index of the field.

///

fn marker_from_name(name: &str) -> Option<Self::FieldMarker>;

/// Get the value from the value protocol.

}

/// Error that [`StructBuilder`] returns.

where

Info: StructTypeInfo<'ctx, M, E>,

{

error: Info::Error,

}

where

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

{

}

}

where

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

{

}

}

where

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

{

}

}

where

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

{

type Value = Info::T;

}

where

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

{

where

'ctx: 'e,

{

match core::mem::replace(&mut self.inner, Inner::Temp) {

builders,

kind: StructKind::Tuple,

};

inner => {

self.inner = inner;

}

}

}

}

where

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

{

where

Self: 'a,

{

inner: Inner::Seed(seed),

}

where

Self: 'a,

{

Inner::Seed(seed) => {

// We may be able to make a value from just the seed.

Info::new_builders(seed)

}

Inner::Builders { builders, .. } => {

// Create the value from the builders.

Info::from_builders(builders)

}

// Use the value as is.

}

}

}

where

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

{

where

'ctx: 'a,

{

}

any_trait! {

RequestHintProto<E>,

ValueProto<Info::ValueT, E>,

TagProto<tags::Struct, E>,

TagProto<tags::Map, E>,

SequenceProto<E>

] where

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

Mode: 'ctx,

}

impl<'ctx, Info, Mode: 'ctx, E> RequestHint<'ctx, E> for StructBuilder<'ctx, Info, Mode, E>

where

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

{

#[inline(always)]

fn request_hint<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

where

'ctx: 'this + 'walker,

{

// Start with a hint to use the value protocol to directly transfer the

// struct value.

hint_protocol::<ValueProto<Info::ValueT, E>, _>(walker.cast(), *this, ()).cast()

.if_not_finished(|(this, walker)| {

// Next hint that the struct protocol should be used to switch into

// map-like if the walker supports it.

)

.cast()

})

}

}

impl<'ctx, Info, Mode, E> Value<'ctx, Info::ValueT, E> for StructBuilder<'ctx, Info, Mode, E>

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

// Get the value from what we got from the walker.

self.inner = Inner::Value(Info::from_value(value));

// Since we have the struct value we are done.

}

}

impl<'ctx, Info, Mode: 'ctx, E> Tag<'ctx, tags::Struct, E> for StructBuilder<'ctx, Info, Mode, E>

where

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

{

fn visit<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

_kind: tags::Struct,

walker: DynWalkerObjSafe<'walker, 'ctx, E>,

// If this protocol is used then we need to create the builders.

if let Inner::Builders { kind, .. } = &mut this.inner {

// This signals to go into map mode for the sequence.

*kind = StructKind::Map;

}

// Walk the walker so nothing complains.

}

}

impl<'ctx, Info, Mode: 'ctx, E> Tag<'ctx, tags::Map, E> for StructBuilder<'ctx, Info, Mode, E>

where

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

{

fn visit<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

_kind: tags::Map,

walker: DynWalkerObjSafe<'walker, 'ctx, E>,

// If this protocol is used then we need to create the builders.

if let Inner::Builders { kind, .. } = &mut this.inner {

// This signals to go into map mode for the sequence.

*kind = StructKind::Map;

}

// Walk the walker so nothing complains.

}

}

impl<'ctx, Info, Mode: 'ctx, E> Sequence<'ctx, E> for StructBuilder<'ctx, Info, Mode, E>

where

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

{

fn visit<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

scope: DynSequenceScope<'b, 'ctx, E>,

where

'ctx: 'a + 'b + 'c,

{

// If this protocol is used then we need to create the builders.

match &mut this.inner {

// We should treat the sequence as just values.

Inner::Builders {

// If we don't have the builders ... we can't do anything.

// This would only happen if the walker gives the value directly

// then gives a sequence.

}

.map(Into::into)

.cast()

}

}

builders: &'a mut I::Builders,

marker: Option<I::FieldMarker>,

_marker: Marker<E>,

}

any_trait! {

TagProto<tags::Key, E>,

] ref {

let (_this, _id);

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

})

} where

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

}

impl<'d, 'ctx, I, M, E> Tag<'ctx, tags::Key, E> for FieldVisitor<'d, 'ctx, I, M, E>

where

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

{

fn visit<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

_key: tags::Key,

walker: DynWalkerObjSafe<'b, 'ctx, E>,

let visitor = NameVisitor::<I, M, E> {

field_marker: None,

_marker: Default::default(),

}

}

field_marker: Option<I::FieldMarker>,

_marker: Marker<E>,

}

any_trait! {

ValueProto<OwnedStatic<usize>, E>,

ValueProto<TempBorrowedStaticHrt<str>, E>,

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

] where

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

}

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

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

self.field_marker = I::marker_from_index(index);

impl<'ctx, I, M, E> Value<'ctx, TempBorrowedStaticHrt<str>, E> for NameVisitor<'ctx, I, M, E>

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

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

impl<'ctx, I, M, E> Value<'ctx, OwnedStatic<&'static str>, E> for NameVisitor<'ctx, I, M, E>

where

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

{

fn visit<'a>(

&'a mut self,

where

'ctx: 'a,

{

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

use core::fmt::Display;

use crate::{

any::{

AnyTrait, BorrowedMutStatic, BorrowedMutStaticHrt, BorrowedStatic, BorrowedStaticHrt,

TempBorrowedStaticHrt,

},

any_trait,

hkt::Marker,

protocol::{

visitor::{

#[non_exhaustive]

pub struct ValueError<T>(Marker<T>);

impl<T> ::core::fmt::Debug for ValueError<T> {

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

write!(f, "missing value of type `{}`", core::any::type_name::<T>())

_marker: Marker<(E, Clone)>,

}

type Error = ValueError<T>;

type Value = T;

type Seed = ();

}

where

{

where

Self: 'a,

{

}

where

Self: 'a,

{

value: None,

_marker: Default::default(),

}

}

where

{

where

'ctx: 'a,

{

}

any_trait! {

RequestHintProto<E>,

ValueProto<OwnedStatic<T>, E>,

] where

}

any_trait! {

RequestHintProto<E>,

ValueProto<OwnedStatic<T>, E>,

ValueProto<BorrowedStaticHrt<T>, E>,

ValueProto<BorrowedMutStaticHrt<T>, E>,

ValueProto<TempBorrowedMutStaticHrt<T>, E>,

] where

}

fn request_hint<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

where

'ctx: 'this + 'walker,

{

hint_protocol::<ValueProto<OwnedStatic<T>, E>, _>(walker.cast(), *this, ()).cast()

}

}

where

{

fn request_hint<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

where

'ctx: 'this + 'walker,

{

hint_protocol::<ValueProto<OwnedStatic<T>, E>, _>(walker.cast(), *this, ()).cast()

.if_not_finished(|(this, walker)| {

hint_protocol::<ValueProto<BorrowedStaticHrt<T>, E>, _>(walker.cast(), *this, ()).cast()

})

hint_protocol::<ValueProto<TempBorrowedMutStaticHrt<T>, E>, _>(walker.cast(), *this, ())

.cast()

})

}

}

for ValueBuilder<T, Clone, E>

{

fn visit<'a>(

&'a mut self,

OwnedStatic(value): OwnedStatic<T>,

where

'ctx: 'a,

{

self.value = Some(value);

}

}

for ValueBuilder<T, Cloneable, E>

where

{

fn visit<'a>(

&'a mut self,

BorrowedStatic(value): BorrowedStatic<'ctx, T>,

where

'ctx: 'a,

{

self.value = Some(value.clone());

}

}

for ValueBuilder<T, Cloneable, E>

where

{

fn visit<'a>(

&'a mut self,

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

where

'ctx: 'a,

{

self.value = Some(value.clone());

}

}

for ValueBuilder<T, Cloneable, E>

where

{

fn visit<'a>(

&'a mut self,

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

where

'ctx: 'a,

{

self.value = Some(value.clone());

}

}

for ValueBuilder<T, Cloneable, E>

where

{

fn visit<'a>(

&'a mut self,

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

where

'ctx: 'a,

{

self.value = Some(value.clone());

}

}

pub mod any;

mod build;

mod doc_macro;

pub mod hkt;

pub mod macros;

pub mod protocol;

use core::ops::ControlFlow;

pub use build::*;

pub use transform::*;

pub use walk::*;

use symbol::Symbol;

pub mod never {

mod sealed {

pub trait Extract {

type Never;

}

/// Test

}

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

Err,

}

#[derive(Clone, Copy, PartialEq, Debug)]

#[must_use]

pub enum Flow {

Done,

}

impl Flow {

pub fn to_status(self) -> Status {

match self {

),* $(,)?}

} => {

const _: () = {

type Walker = $crate::walkers::core::r#struct::StructWalker<'ctx, Info, $crate::any::StaticType, M, E>;

}

}

$vis enum Info {}

#[allow(non_camel_case_types, unused)]

$field($crate::walkers::core::key_value::KeyValueError<$crate::never::Never, <<&'ctx $type as $crate::Walk<'ctx, M, E>>::Walker as $crate::Walker<'ctx, E>>::Error>)

),*}

#[allow(unused)]

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

todo!()

}

}

const NAME: &'static str = stringify!($name);

const FIELDS: &'static [&'static str] = &[$(stringify!($field)),*];

fn walk_field<'a>(

index: usize,

value: &'ctx Self::T,

mod fields {

enum Fields {$($field),*}

$(pub const $field: usize = Fields::$field as usize;)*

}

match index {

$(fields::$field => {

let key_walker = $crate::walkers::core::value::ValueWalker::new(stringify!($field));

#[test]

fn demo() {

assert_eq!(ident(X { a: true, b: false }), Y { a: true, b: false });

crate::effect::blocking::Spin::block_on(async {

#[allow(non_upper_case_globals, non_snake_case, non_camel_case_types)]

const _: () = {

// add a module here to seal fields.

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

}

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

}

#[derive(Copy, Clone, Debug)]

$vis enum Field {

$($field),*

}

mod field_index {

enum __Fields {

$($field),*

$(pub const $field: usize = __Fields::$field as usize;)*

}

}

impl ::core::fmt::Display for Field {

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

f.write_str(match self {

}

}

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

f.write_str(match self {

$(Error::$field(_) => stringify!($field)),*

}

}

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

f.write_str(match self {

$(Error::$field(_) => stringify!($field)),*

$vis struct __Info;

type Builders = Builders<'ctx, M, E>;

type FieldMarker = Field;

type T = $name;

type Error = Error<'ctx, M, E>;

type ValueT = $crate::any::OwnedStatic<$name>;

const FIELD_COUNT: usize = {

};

#[inline(always)]

let ($($field),*) = seed;

}

use $crate::Builder;

}

fn as_visitor<'a>(

marker: Self::FieldMarker,

builders: &'a mut Self::Builders,

use $crate::protocol::AsVisitor;

match marker {

use core::ops::{Deref, DerefMut};

use crate::any::AnyTrait;

DynVisitor(&mut *self.0)

}

}

fn deref(&self) -> &Self::Target {

&*self.0

}

}

fn deref_mut(&mut self) -> &mut Self::Target {

&mut *self.0

}

}

where

'ctx: 'a;

}

where

'ctx: 'a,

{

}

}

DynWalker(&mut *self.0)

}

}

fn deref(&self) -> &Self::Target {

&*self.0

}

}

fn deref_mut(&mut self) -> &mut Self::Target {

&mut *self.0

}

use core::ops::ControlFlow;

use crate::{

never::Never,

Flow, Status,

};

mod tag;

mod value;

pub use recoverable::*;

pub use request_hint::*;

pub use sequence::*;

Control(Flow),

}

impl<S> VisitResult<S> {

pub fn unit_skipped(self) -> VisitResult<()> {

match self {

fn if_skipped<'ctx, 'wrap, Ctx, F>(

self,

f: F,

where

Self: Effective<'lt, Output = (Ctx, VisitResult<()>)>,

F: 'wrap

+ for<'temp> FnOnce(

&'temp mut Ctx,

)

'ctx: 'lt,

'lt: 'wrap,

{

fn if_not_finished<'ctx, 'wrap, Ctx, F>(

self,

f: F,

where

Self: Effective<'lt, Output = (Ctx, VisitResult<()>)>,

F: 'wrap

+ for<'temp> FnOnce(

&'temp mut Ctx,

)

'ctx: 'lt,

'lt: 'wrap,

{

self.r#do(

use crate::{

any::TypeName,

hkt::Marker,

protocol::{

walker::hint::{HasProtocol, HintMeta, Meta},

use super::VisitResult;

fn visit<'a>(

&'a mut self,

scope: DynRecoverableScope<'a, 'ctx, E>,

}

where

{

}

where

{

type Higher = RecoverableProto<E>;

}

fn new_walk<'this: 'effect, 'visitor: 'effect, 'effect>(

&'this mut self,

}

pub type DynRecoverableScope<'a, 'ctx, E> =

pub struct RecoverableKnown;

type T = RecoverableKnown;

}

type Higher = RecoverableKnown;

}

type Known = RecoverableKnown;

type Hint = ();

type Effect = E;

}

scope: DynRecoverableScope<'a, 'ctx, E>,

if let Some(object) = visitor.0.upcast_mut::<RecoverableProto<E>>() {

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

object.visit(scope)

} else {

// If the visitor doesn't support request hint then we continue.

}

}

use crate::{

any::TypeName,

hkt::Marker,

protocol::{DynVisitor, DynWalker},

};

use super::VisitResult;

/// Protocol for requesting a hint from a visitor.

/// Call this to request a hint.

///

/// `walker` is what the visitor (`self`) will call to give a hint using the

/// [`Hint`][crate::builtins::walker::Hint] protocol.

fn request_hint<'this: 'e, 'walker: 'e, 'e>(

&'this mut self,

where

'ctx: 'this + 'walker;

}

where

{

}

where

{

type Higher = RequestHintProto<E>;

}

/// If [`Flow::Done`] is returned then the visitor doesn't need any more information and the walker

/// should stop walking.

/// If [`Flow::Break`] is returned then there was an error and the walker should stop walking.

if let Some(object) = visitor.0.upcast_mut::<RequestHintProto<E>>() {

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

object

.cast()

} else {

// If the visitor doesn't support request hint then we continue.

}

.map(|((_, walker), result)| result.map_skipped(|_| walker))

}

use crate::{

any::TypeName,

hkt::Marker,

protocol::{

walker::hint::{HasProtocol, HintMeta, Meta},

///

/// This protocol uses a scope to give temporary control to the visitor.

/// The visitor will drive the walker for each item.

fn visit<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

scope: DynSequenceScope<'b, 'ctx, E>,

where

'ctx: 'a;

}

where

{

}

where

{

type Higher = SequenceProto<E>;

}

fn next<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

where

'ctx: 'c + 'a + 'b;

}

#[derive(Default)]

pub struct SequenceKnown {

pub len: (usize, Option<usize>),

}

type T = SequenceKnown;

}

type Higher = SequenceKnown;

}

pub len: (usize, Option<usize>),

}

type T = SequenceHint;

}

type Higher = SequenceHint;

}

type Known = SequenceKnown;

type Hint = SequenceHint;

}

#[inline(always)]

scope: DynSequenceScope<'a, 'ctx, E>,

if let Some(object) = visitor.0.upcast_mut::<SequenceProto<E>>() {

// Allow the visitor to walk the sequence scope.

object.visit(scope)

} else {

// If the visitor doesn't support sequence then we continue.

}

}

use core::any::TypeId;

use crate::{

any::TypeName,

hkt::Marker,

protocol::{

walker::hint::{HasProtocol, HintMeta, Meta},

DynVisitor,

},

symbol::Symbol,

};

use super::VisitResult;

pub type TypeId = TagConst<{ Symbol::new("Type ID").to_int() }>;

}

fn symbol(&self) -> Symbol;

}

#[derive(Copy, Clone)]

pub struct TagConst<const SYMBOL: u64>;

#[derive(Copy, Clone)]

pub struct TagDyn(pub Symbol);

fn symbol(&self) -> Symbol {

Symbol::from_int(SYMBOL)

}

pub const VALUE: u64 = SYMBOL;

}

fn symbol(&self) -> Symbol {

self.0

}

}

fn visit<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

kind: K,

walker: DynWalkerObjSafe<'b, 'ctx, E>,

}

where

{

}

where

{

type Higher = TagProto<K, E>;

}

pub kind_available: Option<bool>,

}

type T = TagKnown;

}

type Higher = TagKnown;

}

pub kind: K,

}

for TagHint<K>

{

type T = TagHint<K>;

}

for TagHint<K>

{

type Higher = TagHint<K>;

}

type Known = TagKnown;

type Hint = TagHint<K>;

err: TagErrorKind<E>,

}

impl<E> TagError<E> {

Self {

symbol: tag.symbol(),

err: TagErrorKind::Walker(err),

}

}

Self {

symbol: tag.symbol(),

err: TagErrorKind::NeverWalked,

}

}

Self {

symbol: tag.symbol(),

err: TagErrorKind::WalkNeverFinished,

}

}

Self {

symbol: tag.symbol(),

err: TagErrorKind::SkippedWasWalked,

'ctx: 'visitor,

'visitor: 'wrap,

'wrap,

W: crate::Walker<'ctx, E> + 'wrap,

>(

kind: K,

walker: W,

// Wrap the walker to allow it to be passed to a dyn walker argument.

let walker = DynWalkerAdapter::new(walker);

})

}

kind: K,

err: DynWalkerError<'ctx, W, E>,

) -> TagError<W::Error> {

}

}

//!

//! In some sense, this is the most basic protocol.

use crate::{

any::TypeName,

hkt::Marker,

protocol::{

walker::hint::{HasProtocol, HintMeta, Meta},

/// Trait object for the [`Value`] protocol.

///

/// Types implementing the [`Value`] protocol will implement this trait.

/// Visit a value of type `T`.

///

/// Use this to give a value to a visitor. Its expected that a walker

/// and error.

fn visit<'a>(

&'a mut self,

where

'ctx: 'a;

}

where

{

}

where

{

type Higher = ValueProto<T, E>;

}

pub preview: Option<&'a T>,

}

#[derive(Copy, Clone, Debug)]

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

where

{

}

where

{

}

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

type Known = ValueKnownHrt<T>;

type Hint = ();

'ctx: 'visitor,

'visitor: 'e,

'e,

>(

value: T,

if let Some(object) = visitor

.0

{

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

object.visit(value)

} else {

// If the visitor doesn't support request hint then we continue.

}

}

T: Value<'ctx, U, E>

{

}

use core::ops::{Deref, DerefMut};

use crate::{

any::{AnyTrait, TypeName},

hkt::Marker,

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

Flow,

#[allow(non_snake_case)]

pub mod Meta {

}

}

{

}

}

type T = ();

}

type Higher = ();

}

/// Meta information for the hint.

///

/// This gives the visitor more information to work from when selecting a hint.

/// Information known by the walker.

///

/// This should be information easy to get without changing the state of the walker

/// in an irreversible way.

/// Extra information the visitor can give to the walker about what it is expecting.

}

/// Object implementing the [`Hint`] protocol.

/// Hint to the walker to use the `P` protocol.

///

/// This should only be called once per [`RequestHint`].

&'this mut self,

visitor: DynVisitorWith<'visitor, 'ctx, Protocol>,

hint: MetaHint<'hint, 'ctx, Protocol>,

where

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

fn known<'a>(

&'a mut self,

hint: &'a MetaHint<'a, 'ctx, Protocol>,

}

_marker: Marker<Protocol>,

}

impl<'temp, 'ctx: 'temp, Protocol: ?Sized + HintMeta> DynVisitorWith<'temp, 'ctx, Protocol> {

pub fn new<T>(visitor: &'temp mut T) -> Self

where

{

Self {

visitor: DynVisitor(visitor),

}

}

self.visitor.upcast_mut::<Protocol>().unwrap()

}

self.visitor

}

}

fn deref(&self) -> &Self::Target {

&self.visitor

}

}

fn deref_mut(&mut self) -> &mut Self::Target {

&mut self.visitor

}

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

for HintProto<Protocol>

where

Protocol: HintMeta,

{

}

where

Protocol: HintMeta,

{

}

pub fn hint_protocol<

'walker: 'e,

'visitor: 'e,

'hint: 'e,

Protocol: ?Sized + HintMeta,

T,

>(

visitor: &'visitor mut T,

hint: MetaHint<'hint, 'ctx, Protocol>,

where

{

if let Some(object) = walker.0.upcast_mut::<HintProto<Protocol>>() {

object

use futures::Future;

use crate::{

build::Builder,

Build, BuilderTypes, DefaultMode, Walk, Walker,

};

#[inline(always)]

#[allow(clippy::type_complexity)]

seed: B::Seed,

walker: W,

B::from_seed(seed)

.then(|(builder, walker_result)| {

builder

.build()

walker: W,

) -> Result<

Self,

>

where

{

(Ok(value), _) => Ok(value),

(Err(err), Ok(_)) => Err(BuildError::Builder(err)),

(Err(build_err), Err(walker_err)) => Err(BuildError::Both(build_err, walker_err)),

) -> impl Future<

Output = Result<

Self,

>,

> + Send

+ Sync

where

{

async {

.into_future()

.await

{

fn new_builder<'ctx>() -> Self::Builder

where

{

}

}

impl<T> BuildExt for T {}

pub trait WalkExt {

where

{

}

fn as_async_walker<'ctx: 'a, 'a>(

&'a self,

where

{

Walk::into_walker(self).into_future()

}

#[allow(clippy::result_unit_err)]

fn walk<'ctx: 'a, 'a, B>(&'a self, builder: B) -> Result<B::Value, ()>

where

{

let mut builder = builder;

Ok(value) => Ok(value),

_ => todo!(),

}

use core::fmt::Debug;

use crate::{

protocol::DynVisitor,

Flow,

};

/// A type that can be walked.

/// The walker for the type.

type Walker: Walker<'ctx, E>;

#[must_use]

where

Self: 'e;

}

/// - Call [From::from()] with a value to be walked to make a walker.

/// - Call [Self::walk()] to walk the value. Data will be sent to the provided

/// visitor.

/// An arbitrary type the walker is left with after walking.

///

/// Its recommended that this is `Self` if the walker is repeatable.

/// Walk the value.

///

/// The walker should send data to the `visitor` as it walks the value.

fn walk<'visitor: 'effect, 'effect>(

self,

where

Self: 'effect;

}

fn walk<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

where

Self: 'a;

}

Walking,

Pending(W),

Done(W::Output),

Err(W::Error),

}

NeverWalked(W),

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

WasWalked(W::Output),

}

state: DynWalkerState<'ctx, W, E>,

}

#[inline(always)]

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

Self {

}

}

#[inline(always)]

fn walk<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

where

Self: 'a,

{

if let DynWalkerState::Pending(walker) =

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

{

// Walk the walker.

walker

.walk(visitor.cast())

.cast()

})

.map(|(_, value)| value)

} else {

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

}

}

}

pub mod core;

use crate::{

Walk,

};

use super::value::ValueWalker;

type Walker = ValueWalker<bool>;

E::ready(ValueWalker::new(self))

}

}

type Walker = ValueWalker<bool>;

E::ready(ValueWalker::new(*self))

}

}

use crate::{

any::OwnedStatic,

any_trait,

hkt::Marker,

never::Never,

protocol::{

_marker: Marker<E>,

}

pub trait Integer:

'static

+ Copy

+ core::fmt::Debug

+ core::fmt::Display

+ TryInto<u8>

+ TryInto<u16>

+ TryInto<u32>

value: T,

}

impl<T: Integer> ::core::fmt::Debug for IntegerWalkerError<T> {

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

f.debug_struct("IntegerWalkerError")

}

}

type Error = IntegerWalkerError<T>;

type Output = T;

fn walk<'visitor: 'effect, 'effect>(

self,

where

Self: 'effect,

{

+ Copy

+ core::fmt::Debug

+ core::fmt::Display

+ TryInto<u8>

+ TryInto<u16>

+ TryInto<u32>

}

any_trait! {

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

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

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

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

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

] where

}

macro_rules! impl_hints {

($($type:ty),* $(,)?) => {

for IntegerWalker<T, E>

{

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

&'this mut self,

visitor: DynVisitorWith<'visitor, 'ctx, ValueProto<OwnedStatic<$type>, E>>,

_hint: MetaHint<'hint, 'ctx, ValueProto<OwnedStatic<$type>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a MetaHint<'a, 'ctx, ValueProto<OwnedStatic<$type>, E>>,

{

E::ready(Ok(ValueKnown { preview: None }))

}

use crate::{

never::Never,

protocol::{

visitor::{tags, visit_tag, EffectiveVisitExt as _, TagConst, TagError, TagKind},

_tag: T,

}

impl<T, K, V> KeyValueWalker<T, K, V> {

#[inline(always)]

pub fn new(tag: T, key_walker: K, value_walker: V) -> Self {

#[derive(Debug)]

pub struct KeyValueError<K, V>(KeyValueErrorKind<K, V>);

impl<'ctx, T, K, V, E> crate::Walker<'ctx, E> for KeyValueWalker<T, K, V>

where

K: crate::Walker<'ctx, E> + 'ctx,

V: crate::Walker<'ctx, E> + 'ctx,

{

#[inline(always)]

fn walk<'b: 'c, 'c>(

self,

let Self {

key_walker,

value_walker,

use crate::{

never::Never,

protocol::DynVisitor,

};

#[derive(Debug, Default)]

pub struct NoopWalker;

impl NoopWalker {

pub fn new() -> Self {

Self

}

}

type Error = Never;

type Output = ();

fn walk<'b: 'c, 'c>(

self,

}

}

use core::any::TypeId;

use crate::{

any::{AnyTrait, BorrowedStatic, BorrowedStaticHrt, StaticType},

any_trait,

hkt::Marker,

never::Never,

protocol::{

/// Walker for a borrow of a struct.

///

/// This walker implements the struct flow. The struct cannot contain lifetimes.

/// Struct value to walk.

value: &'ctx I::T,

_generics: Marker<E>,

}

/// Type info about a struct needed by [`StructWalker`].

/// Name of the struct.

const NAME: &'static str;

const FIELDS: &'static [&'static str];

/// The walking errors for the fields.

type S: 'static;

/// The struct being described.

/// Walk the given field.

fn walk_field<'a>(

index: usize,

value: &'ctx Self::T,

}

#[derive(Debug, PartialEq, Clone, Copy)]

kind: StructWalkErrorKind<T>,

}

where

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

{

impl<'ctx, I, S, E, M> crate::Walker<'ctx, E> for StructWalker<'ctx, I, S, M, E>

where

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

{

type Error = StructWalkError<I::FieldError>;

type Output = ();

#[inline(always)]

fn walk<'b: 'c, 'c>(

self,

where

Self: 'c,

{

}

any_trait! {

HintProto<RecoverableProto<E>>,

HintProto<SequenceProto<E>>,

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

HintProto<TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>,

HintProto<TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>>,

] where

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

M: 'ctx,

}

impl<'ctx, I, S, M, E> Hint<'ctx, RecoverableProto<E>> for StructWalker<'ctx, I, S, M, E>

where

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

{

#[inline(always)]

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

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, RecoverableProto<E>>,

_hint: MetaHint<'hint, 'ctx, RecoverableProto<E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <RecoverableProto<E> as HintMeta>::Hint,

E::ready(Ok(RecoverableKnown))

}

}

impl<'ctx, I, S, M, E> Hint<'ctx, TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>>

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

where

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

{

#[inline(always)]

TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>,

>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a MetaHint<'a, 'ctx, TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>>,

'a,

Result<MetaKnown<'a, 'ctx, TagProto<TagConst<{ TAG_FIELD_NAMES.to_int() }>, E>>, ()>,

E,

impl<'ctx, I, S, M, E> Hint<'ctx, TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>

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

where

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

{

#[inline(always)]

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E> as HintMeta>::Hint,

'a,

Result<MetaKnown<'a, 'ctx, TagProto<TagConst<{ TAG_TYPE_NAME.to_int() }>, E>>, ()>,

E,

impl<'ctx, I, S, M, E> Hint<'ctx, TagProto<TagConst<{ TAG_MAP.to_int() }>, E>>

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

where

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

{

#[inline(always)]

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, TagProto<TagConst<{ TAG_MAP.to_int() }>, E>>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagConst<{ TAG_MAP.to_int() }>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <TagProto<TagConst<{ TAG_MAP.to_int() }>, E> as HintMeta>::Hint,

'a,

Result<MetaKnown<'a, 'ctx, TagProto<TagConst<{ TAG_MAP.to_int() }>, E>>, ()>,

E,

impl<'ctx, I, S, M, E> Hint<'ctx, TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E>>

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

where

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

{

#[inline(always)]

&'this mut self,

visitor: DynVisitorWith<'visitor, 'ctx, TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E>>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E> as HintMeta>::Hint,

'a,

Result<MetaKnown<'a, 'ctx, TagProto<TagConst<{ TAG_STRUCT.to_int() }>, E>>, ()>,

E,

impl<'ctx, I, M, E> Hint<'ctx, TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E>>

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

where

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

I::T: 'static,

{

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E>>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E> as HintMeta>::Hint,

'a,

Result<MetaKnown<'a, 'ctx, TagProto<TagConst<{ TAG_TYPE_ID.to_int() }>, E>>, ()>,

E,

impl<'ctx, I, M, E> Hint<'ctx, TagProto<TagDyn, E>> for StructWalker<'ctx, I, StaticType, M, E>

where

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

I::T: 'static,

{

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, TagProto<TagDyn, E>>,

_hint: MetaHint<'hint, 'ctx, TagProto<TagDyn, E>>,

where

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

{

fn known<'a>(

&'a mut self,

hint: &'a <TagProto<TagDyn, E> as HintMeta>::Hint,

E::ready(match hint.kind {

TagDyn(crate::TAG_TYPE_ID) | TagDyn(crate::TAG_STRUCT) => Ok(TagKnown {

kind_available: Some(true),

impl<'ctx, I, M, E> Hint<'ctx, ValueProto<BorrowedStaticHrt<I::T>, E>>

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

where

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

{

#[inline(always)]

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

&'this mut self,

_visitor: DynVisitorWith<'visitor, 'ctx, ValueProto<BorrowedStaticHrt<I::T>, E>>,

_hint: MetaHint<'hint, 'ctx, ValueProto<BorrowedStaticHrt<I::T>, E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a (),

E::ready(Ok(ValueKnown { preview: None }))

}

}

impl<'ctx, I, S, M: 'ctx, E> Hint<'ctx, SequenceProto<E>> for StructWalker<'ctx, I, S, M, E>

where

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

{

#[inline(always)]

&'this mut self,

visitor: DynVisitorWith<'visitor, 'ctx, SequenceProto<E>>,

_hint: MetaHint<'hint, 'ctx, SequenceProto<E>>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a <SequenceProto<E> as HintMeta>::Hint,

let len = I::FIELDS.len();

E::ready(Ok(SequenceKnown {

impl<'ctx, I, S, M: 'ctx, E> SequenceScope<'ctx, E> for StructWalker<'ctx, I, S, M, E>

where

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

{

#[inline(always)]

let len = I::FIELDS.len();

E::ready((len, Some(len)))

#[inline(always)]

fn next<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

if self.index >= I::FIELDS.len() {

return Flow::Done.ready();

}

impl<'ctx, I, M: 'ctx, E> RecoverableScope<'ctx, E> for StructWalker<'ctx, I, StaticType, M, E>

where

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

I::T: 'static,

{

#[inline(always)]

fn new_walk<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

// Reset the errors to default state.

self.error = None;

use core::marker::PhantomData;

use crate::{

any_trait,

never::Never,

protocol::{

visitor::{SequenceScope, TagError},

_marker: PhantomData<fn() -> W>,

}

impl<T, W> StaticSliceWalker<T, W> {

pub fn new(names: &'static [T]) -> Self {

Self {

impl<'ctx, T, W, E> crate::Walker<'ctx, E> for StaticSliceWalker<T, W>

where

W: crate::Walker<'ctx, E, Output = ()>,

&'static T: Into<W>,

{

type Error = TagError<Never>;

#[inline(always)]

fn walk<'b: 'c, 'c>(

self,

todo!()

// E::wrap(async move {

// match visit_request_hint::<E>(visitor.cast(), DynWalker(&mut self)).await {

}

any_trait! {

}

impl<'ctx, T, W, E> SequenceScope<'ctx, E> for StaticSliceWalker<T, W>

where

W: crate::Walker<'ctx, E, Output = ()>,

&'static T: Into<W>,

{

#[inline(always)]

fn next<'a: 'c, 'b: 'c, 'c>(

&'a mut self,

if let Some(_name) = self.names.get(self.current) {

self.current += 1;

todo!()

// }

// })

} else {

}

}

#[inline(always)]

}

}

use crate::{

any::{BorrowedStatic, OwnedStatic, TempBorrowedStatic},

never::Never,

protocol::{

visitor::{visit_value, EffectiveVisitExt as _, VisitResult},

#[derive(Debug)]

pub struct ValueWalker<T>(T);

impl<T> ValueWalker<T> {

/// Create walker from a value.

#[inline(always)]

}

}

type Error = Never;

type Output = ();

#[inline(always)]

fn walk<'b: 'c, 'c>(

self,

// Attempt to visit using the value protocol.

visit_value::<_, E>(visitor, OwnedStatic(self.0)).map(|_| Ok(()))

}

/// This walker supports values borrowed for `'ctx` or longer.

pub struct BorrowWalker<'ctx, T: ?Sized>(&'ctx T);

impl<'ctx, T: ?Sized> BorrowWalker<'ctx, T> {

/// Create walker from a value.

#[inline(always)]

}

}

for BorrowWalker<'ctx, T>

{

type Error = Never;

#[inline(always)]

fn walk<'b: 'c, 'c>(

self,

// Attempt to visit using the value protocol.

E::as_ctx((self, visitor), |(this, visitor)| {

visit_value::<_, E>(visitor.cast(), BorrowedStatic(this.0))