checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"

[[package]]

name = "autocfg"

version = "1.1.0"

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

checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]

name = "errno"

version = "0.3.8"

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

checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

[[package]]

name = "getrandom"

version = "0.2.12"

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

]

[[package]]

name = "num-traits"

version = "0.2.17"

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

checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

[[package]]

name = "proc-macro2"

version = "1.0.76"

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

]

[[package]]

name = "tokio"

version = "1.36.0"

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

version = "0.0.1"

dependencies = [

"macro_rules_attribute",

"proptest",

"serde",

"serde_json",

[dev-dependencies]

macro_rules_attribute = "0.2.0"

proptest = "1.4.0"

serde_json = "1.0.114"

tokio = { version = "1.36.0", features = ["full"] }

//! without unsafe code. However, its recommended to use the provided [`nameable`]

//! macro when possible.

use core::{

marker::{PhantomData, PhantomPinned},

mem::{ManuallyDrop, MaybeUninit},

#[cfg(all(feature = "alloc", not(feature = "std")))]

use alloc::boxed::Box;

}

}

{

{

}

}

}

}

}

}

}

}

/// [`TypeId`][core::any::TypeId] with a lifetime generic `'lt`.

///

///

/// The type must implement [`TypeNameable`]. Note, the `'a` lifetime is **not**

/// tracked by the [`LtTypeId`], only the `'lt` lifetime is.

LtTypeId {

_marker: PhantomData,

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

}

}

pub trait Sealed<'lt> {}

}

fn type_id(&self) -> LtTypeId<'lt> {

LtTypeId::of::<T>()

}

impl<'a, 'lt> dyn LtAny<'lt> + 'a {

/// Check if `self` is of type `T`.

LtTypeId::of::<T>() == self.type_id()

}

/// Downcast a `&dyn LtAny<'lt>` into a `&T`.

if self.is::<T>() {

Some(unsafe { &*(self as *const dyn LtAny<'lt> as *const T) })

} else {

}

/// Downcast a `&mut dyn LtAny<'lt>` into a `&mut T`.

if self.is::<T>() {

Some(unsafe { &mut *(self as *mut dyn LtAny<'lt> as *mut T) })

} else {

/// Downcast a `Box<dyn LtAny<'lt>>` into a `Box<T>`.

#[cfg(feature = "alloc")]

if self.is::<T>() {

Ok(unsafe {

let raw: *mut dyn LtAny<'lt> = Box::into_raw(self);

/// as it automatically downcasts the returned [`IndirectLtAny`].

///

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

self.upcast_to_id(LtTypeId::of::<Trait>())

.map(|object| match object.downcast::<Trait>() {

Ok(object) => object,

/// as it automatically downcasts the returned [`IndirectLtAny`].

///

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

&'a mut self,

self.upcast_to_id_mut(LtTypeId::of::<Trait>())

.map(|object| match object.downcast::<Trait>() {

Ok(object) => object,

/// Wrap an indirection.

///

/// The inner type `T` of the indirection is erased.

Self {

info: || {

(LtTypeId::of::<T>(), |raw| {

// SAFETY: This is only called in the drop impl.

})

},

indirect: I::into_raw(indirect),

///

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

/// returned as is.

let (id, _) = (self.info)();

if id == LtTypeId::of::<T>() {

} else {

Err(self)

}

#[cfg(feature = "alloc")]

pub use boxed::*;

#[cfg(feature = "alloc")]

mod boxed {

use super::*;

#[cfg(test)]

mod test {

#[test]

fn implementer_macro() {

}

}

}

}

}

any_trait! {

]

}

}

}

nameable! {

pub struct Name['a, 'lt, T];

impl [T] for OwnedStatic<T> where { T: ?Sized + 'static }

}

/// Impl of [`TypeNameable`] for `'static` types that are borrowed (`&'lt T`).

nameable! {

pub struct Name['a, 'lt, T];

}

/// Impl of [`TypeNameable`] for `'static` types that are temporarily borrowed (`&'a T`).

nameable! {

pub struct Name['a, 'lt, T];

impl [T] for TempBorrowedStatic<'a, T> where { T: ?Sized + 'static }

}

/// Impl of [`TypeNameable`] for `'static` types that are borrowed mutably (`&'lt mut T`).

nameable! {

pub struct Name['a, 'lt, T];

}

/// Impl of [`TypeNameable`] for `'static` types that are temporarily borrowed mutably (`&'a mut T`).

nameable! {

pub struct Name['a, 'lt, T];

impl [T] for TempBorrowedMutStatic<'a, T> where { T: ?Sized + 'static }

}

/// Impl of [`TypeNameable`] for `'static` types that are in a [`Box`] (`Box<T>`).

nameable! {

pub struct Name['a, 'lt, T];

impl [T] for BoxedStatic<T> where { T: ?Sized + 'static }

}

#[derive(Debug)]

/// This is expected to just be `self`.

fn as_visitor(&mut self) -> Visitor<'_, 'ctx>;

}

] where E: Effect<'ctx>

}

#[inline]

self.0 = Some(value);

E::ready(Flow::Continue)

}

request_hint::{DynRequestHint, RequestHint},

sequence::{DynSequence, Sequence},

tag::{DynTag, Tag, TagDyn},

},

},

DynWalker, Flow,

crate::TAG_TYPE_NAME => {

self.tab();

println!("type name:");

self.0 += 1;

walker.walk(self).await;

self.0 -= 1;

Status::r#continue()

crate::TAG_KEY => {

self.tab();

println!("key:");

self.0 += 1;

walker.walk(self).await;

self.0 -= 1;

Status::r#continue()

crate::TAG_VALUE => {

self.tab();

println!("value:");

self.0 += 1;

walker.walk(self).await;

self.0 -= 1;

Status::r#continue()

}

})

}

}

&'a mut self,

OwnedStatic(value): OwnedStatic<&'static str>,

) -> Future<'a, 'ctx, Flow, E>

{

self.tab();

println!("{:?}", value);

}

}

{

self.tab();

println!("{}", value);

}

}

{

self.tab();

println!("{}", value);

}

}

for Visitor<E>

{

&'a mut self,

OwnedStatic(value): OwnedStatic<&'static [&'static str]>,

) -> Future<'a, 'ctx, Flow, E>

{

self.tab();

println!("{:?}", value);

}

}

{

self.tab();

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

where $($($bound)*)? $($($for_bound)*)?

{

}

pub trait Trait<$ctx $(, $($generic)*)?>: for<$lt> ForLt<$lt, $ctx, $crate::hkt::Bound<$lt, $ctx $(, $($generic)*)?> $(, $($generic)*)?>

};

}

#[doc(inline)]

pub use higher_ranked_trait;

#[doc(inline)]

pub use higher_ranked_type;

higher_ranked_trait! {

pub type class AnySend['ctx]: [for<'lt> Send]

}

extern crate alloc;

pub mod any;

pub mod effect;

pub mod hkt;

pub mod symbol;

// pub use build::Build;

// pub use build::Builder;

use core::ops::ControlFlow;

use symbol::Symbol;

// #[doc(hidden)]

pub mod macros;

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

let value_walker = <&'ctx $type as $crate::Walk::<'ctx, M, E>>::into_walker(&value.$field);

let walker = $crate::walkers::core::key_value::KeyValueWalker::<$crate::protocol::visitor::tag::TagConst<{ $crate::TAG_FIELD.to_int() }>, _, _>::new($crate::protocol::visitor::tag::TagConst, key_walker, value_walker);

E::map($crate::Walker::<'ctx, E>::walk(walker, visitor), |result| match result {

pub b: bool,

}

/// The protocol was not used.

Skipped(S),

}

impl<S> Status<S> {

Status::Flow(value)

}

}

pub type DynRecoverable<'a, 'ctx, E> = &'a mut (dyn Recoverable<'ctx, E> + Send + 'a);

nameable! {

impl [E] for DynRecoverable<'a, 'ctx, E> where {

E: Effect<'ctx>,

}

}

pub type DynRequestHint<'a, 'ctx, E> = dyn RequestHint<'ctx, E> + Send + 'a;

nameable! {

impl [E] for DynRequestHint<'a, 'ctx, E> where {

E: Effect<'ctx>,

}

}

pub type DynSequence<'a, 'ctx, E> = dyn Sequence<'ctx, E> + Send + 'a;

nameable! {

impl [E] for DynSequence<'a, 'ctx, E> where {

E: Effect<'ctx>,

}

}

pub type DynTag<'a, 'ctx, K, E> = dyn Tag<'ctx, K, E> + Send + 'a;

nameable! {

impl [K, E] for DynTag<'a, 'ctx, K, E> where {

K: TagKind,

E: Effect<'ctx>,

}

}

W: WalkerTypes,

{

E::wrap(async move {

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

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

// Visit the tag.

} else {

return Ok(Status::Skipped(walker));

match flow {

// The walker was skipped.

},

},

}

})

/// 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

/// If a [`ControlFlow::Break`] is returned then the walker

/// should stop walking as soon as possible as there has likely been

/// and error.

}

nameable! {

impl [T::Name, E] for DynValue<'a, 'ctx, T, E> where {

E: Effect<'ctx>,

}

impl [T, E] where DynValue<'a, 'ctx, T::Nameable, E> {

E: Effect<'ctx>,

}

}

type Hint = ();

}

visitor: Visitor<'a, 'ctx>,

value: T,

) -> Future<'a, 'ctx, Status, E> {

fn visit() {

struct Visitor<E>(Option<i32>, PhantomData<fn() -> E>);

where

E: Effect<'ctx>,

{

&'a mut self,

OwnedStatic(value): OwnedStatic<i32>,

) -> Future<'a, 'ctx, Flow, E> {

}

}

where

E: Effect<'ctx>,

{

&'a mut self,

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

) -> Future<'a, 'ctx, Flow, E> {

fn visit_borrowed() {

struct Visitor<'ctx, E>(Option<&'ctx mut String>, PhantomData<fn() -> E>);

where

E: Effect<'ctx>,

{

&'a mut self,

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

) -> Future<'a, 'ctx, Flow, E> {

fn visit_borrowed_unsized() {

struct Visitor<'ctx, E>(Option<&'ctx str>, PhantomData<fn() -> E>);

where

E: Effect<'ctx>,

{

&'a mut self,

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

) -> Future<'a, 'ctx, Flow, E> {

pub type DynHint<'a, 'ctx, Protocol, E> = dyn Hint<'a, 'ctx, Protocol, E> + Send + 'a;

nameable! {

impl [Protocol::Name, E] for DynHint<'a, 'ctx, Protocol, E> where {

E: Effect<'ctx>,

}

impl [Protocol, E] where DynHint<'a, 'ctx, Protocol::Nameable, E> {

E: Effect<'ctx>,

}

}

// pub mod array;

pub mod bool;

pub mod noop;

pub mod r#struct;

pub mod tag;

pub mod value;

pub struct KeyValueWalker<T, K, V> {

key_walker: K,

#[derive(Debug)]

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

where

K: WalkerTypes,

V: WalkerTypes,

type Output = ();

}

where

E: Effect<'ctx>,

T: TagKind,

visitor: Visitor<'a, 'ctx>,

) -> Future<'a, 'ctx, Result<Self::Output, Self::Error>, E>

where

{

E::wrap(async move {

match visit_tag::<T, E, _>(self.tag, visitor, NoopWalker::new()).await {

Ok(Status::Skipped(_)) => {

{

Ok(Status::Flow(flow)) => return Ok(()),

Err(_) => todo!(),

}

}

Ok(Status::Flow(flow)) => todo!(),

Err(_) => todo!(),

}

{

Ok(Status::Flow(flow)) => return Ok(()),

Err(_) => todo!(),

}

{

Ok(Status::Skipped(value_walker)) => {

// Fallback to just walking the value.

match value_walker.walk(visitor).await {

Err(err) => todo!(),

}

Ok(Status::Flow(flow)) => todo!(),

Err(_) => todo!(),

}

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

) -> Future<'a, 'ctx, Flow, E> {

E::map(

|status| match status {

Err(err) => {

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

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

) -> Future<'a, 'ctx, Flow, E> {

E::map(

|status| match status {

Err(err) => {

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

Ok(Status::Flow(flow)) => return flow,

}

Ok(Status::Skipped(_)) => {

{

Err(err) => {

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

Ok(Status::Flow(flow)) => return flow,

}

{

Err(err) => {

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

{

E::wrap(async move {

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

_ => return Ok(()),

}

_ => return Ok(()),

}