# include = ["LICENSE-APACHE", "LICENSE-MIT", "README.md", "empty.rs"]

[dependencies]

futures = "0.3.30"

pin-project = "1.1.5"

# serde = { version = "1.0", default-features = false, optional = true }

serde_json = "1.0.114"

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

[profile.test.package.proptest]

opt-level = 3

where

Self: 'a,

{

}

#[inline(always)]

where

Self: 'a,

{

}

#[inline(always)]

'ctx: 'a,

{

self.0 = Some(value);

}

}

use crate::{

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

any_trait,

hkt::Marker,

protocol::{

visitor::{

},

DynVisitor,

},

};

use super::NoopVisitor;

where

Self: 'a,

{

}

fn build<'a>(self) -> ErasedEffective<'a, Result<Self::Value, Self::Error>, E>

Self: 'a,

{

I::from_builders(self.builders)

}

fn as_visitor(&mut self) -> DynVisitor<'_, 'ctx> {

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

self.mode = StructMode::Map;

}

}

E: Effect,

{

#[inline(always)]

&'a mut self,

match self.mode {

StructMode::Tuple => {

}

})

}

}

}

};

E::ready((self, visitor, walker))

.map(|((this, visitor, _), flow)| {

this.marker = visitor.field_marker;

flow.to_continue().into()

})

}

}

{

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

}

}

{

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

}

}

{

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

}

}

use core::{future::Future, ops::ControlFlow};

// Goal: code using the module shouldn't care if the underlying environment is async or not.

// That is the API should allow yielding without forcing it.

F::Output: Ss + 'a;

}

}

}

}

}

}

}

where

{

}

where

{

}

}

pub trait EffectiveExt<'lt>: Effective<'lt> {

where

where

where

where

self,

f: F,

where

'lt: 'wrap,

{

}

where

'lt: 'wrap,

{

}

where

{

}

self,

f: F,

where

'lt: 'wrap,

{

},

)

}

}

/// The effect the effective belongs to.

type Effect: Effect;

/// Convert the effective into a general future for use in async.

fn into_future(self) -> Self::IntoFuture;

self,

where

'lt: 'wrap;

}

<E as TryJoin>::two(self)

}

}

impl<B: BlockOn> Effect for Blocking<B> {

type Erased<T: Ss> = Value<T, B>;

fn ready<'a, T: Ss + 'a>(value: T) -> ErasedEffective<'a, T, Self> {

Value(value, Default::default())

}

fn from_future<'a, F: Ss + 'a>(future: F) -> ErasedEffective<'a, F::Output, Self>

where

F: Future,

}

impl<'lt, U: Ss + 'lt, B: BlockOn> Effective<'lt> for Value<U, B> {

self

}

core::future::ready(self.0)

}

self,

where

'lt: 'wrap,

{

}

}

}

T0: Effective<'a, Effect = Self::Effect>,

T1: Effective<'a, Effect = Self::Effect>,

{

Value((v0, v1), Default::default())

}

T1: Effective<'a, Effect = Self::Effect>,

T2: Effective<'a, Effect = Self::Effect>,

{

Value((v0, v1, v2), Default::default())

}

F0: FnOnce() -> T0,

F1: FnOnce() -> T1,

{

Ok(v) => v,

Err(err) => return Value(Err(err), Default::default()),

};

Ok(v) => v,

Err(err) => return Value(Err(err), Default::default()),

};

F1: FnOnce() -> T1,

F2: FnOnce() -> T2,

{

Ok(v) => v,

Err(err) => return Value(Err(err), Default::default()),

};

Ok(v) => v,

Err(err) => return Value(Err(err), Default::default()),

};

Ok(v) => v,

Err(err) => return Value(Err(err), Default::default()),

};

mod transform;

mod walk;

pub use build::*;

pub use transform::*;

pub use walk::*;

pub enum DefaultMode {}

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

#[must_use]

Done,

}

impl Flow {

pub fn to_done(self) -> Self {

match self {

Flow::Continue | Flow::Done => Flow::Done,

Flow::Err => Flow::Err,

}

}

}

#[macro_export]

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

}

match index {

$(fields::$field => {

Err(err) => {

Err(FieldError(FieldErrorKind::$field(err)))

}

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

// Ok(_) => {

// }

// })

})*

}

}

}

// todo!();

// }

// }

fn new_builders<'a>(seed: Self::Seed) -> $crate::effect::ErasedEffective<'a, Self::Builders, E> {

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

$crate::effect::join(

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

Builders {

$($field),*

}

// E::wrap(async move {

// Builders {

fn from_builders<'a>(builders: Self::Builders) -> $crate::effect::ErasedEffective<'a, Result<Self::T, Self::Error>, E> {

use $crate::Builder;

$crate::effect::try_join(

(

$($field),*

}),

Err(err) => Err(err)

// E::wrap(async {

// Ok($name {

mod recoverable;

mod request_hint;

Control(Flow),

}

impl<S> PartialEq for VisitResult<S> {

fn eq(&self, other: &Self) -> bool {

match (self, other) {

use crate::{

any::TypeName,

higher_ranked_type,

hkt::Marker,

protocol::{

object.visit(scope)

} else {

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

}

}

use crate::{

any::TypeName,

higher_ranked_type,

hkt::Marker,

protocol::{DynVisitor, DynWalker},

object.request_hint(walker)

} else {

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

}

}

use crate::{

any::TypeName,

higher_ranked_type,

hkt::Marker,

protocol::{

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

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

pub trait Sequence<'ctx, E: Effect> {

&'a mut self,

}

pub struct SequenceProto<E: Effect>(Marker<E>);

pub trait SequenceScope<'ctx, E: Effect> {

fn size_hint(&mut self) -> ErasedEffective<'_, (usize, Option<usize>), E>;

}

pub type DynSequenceScope<'a, 'ctx, E> = &'a mut (dyn SequenceScope<'ctx, E> + Send + Sync + 'a);

object.visit(scope)

} else {

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

}

}

use crate::{

any::TypeName,

higher_ranked_type,

hkt::Marker,

protocol::{

DynVisitor,

},

symbol::Symbol,

};

use super::VisitResult;

pub enum TagErrorKind<E> {

NeverWalked,

/// finish.

WalkNeverFinished,

}

#[inline(always)]

kind: K,

walker: W,

where

W: WalkerTypes,

{

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

let walker = DynWalkerAdapter::new(walker);

E::ready((kind, visitor, walker))

})

.map(|((kind, _, walker), result)| match result {

Some(flow) => Ok(VisitResult::Control(flow)),

None => match walker.into_inner() {

Ok(walker) => Ok(VisitResult::Skipped(walker)),

Err(err) => Err(map_walker_err(kind, err)),

},

})

}

fn map_walker_err<K: TagKind, W: WalkerTypes>(

kind: K,

err: DynWalkerError<W>,

use crate::{

any::TypeName,

higher_ranked_type,

hkt::Marker,

protocol::{

object.visit(value)

} else {

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

}

}

use crate::{

build::Builder,

hkt::Marker,

BuilderTypes, Walk, Walker, WalkerTypes,

};

walker: W,

) -> ErasedEffective<'a, (Result<B::Value, B::Error>, Result<W::Output, W::Error>), E> {

B::from_seed(seed)

.then(|(builder, walker_result)| {

builder

.build()

.map(|builder_result| (builder_result, walker_result))

})

// B::from_seed(seed).map_with(walker, |builder, walker| walker.walk(builder.as_visitor()));

// E::wrap(async {

pub mod walkers;

use crate::{

protocol::DynVisitor,

Flow,

};

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

{

E::ready((self, visitor))

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

} else {

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

}

}

}

use core::marker::PhantomData;

use crate::{

never::Never,

protocol::{

DynVisitor,

},

walkers::core::noop::NoopWalker,

Flow, WalkerTypes, TAG_KEY, TAG_KEY_VALUE, TAG_VALUE,

};

pub struct KeyValueWalker<T, K, V> {

key_walker: K,

value_walker: V,

where

E: Effect,

T: TagKind,

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

{

#[inline(always)]

self,

visitor: DynVisitor<'b, 'ctx>,

) -> ErasedEffective<'c, Result<Self::Output, Self::Error>, E> {

// E::wrap(async move {

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

self,

_visitor: DynVisitor<'b, 'ctx>,

) -> ErasedEffective<'c, Result<Self::Output, Self::Error>, E> {

}

}

use crate::{

any::{AnyTrait, BorrowedStatic, BorrowedStaticHrt},

any_trait,

hkt::Marker,

never::Never,

protocol::{

visitor::{

visit_recoverable, visit_request_hint, visit_sequence, visit_tag, visit_value,

},

walker::hint::{Hint, HintMeta, HintProto, MetaHint, MetaKnown},

DynVisitor, DynWalker,

_generics: Default::default(),

}

}

}

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

{

E::ready((self, visitor))

.as_ctx(

#[inline(always)]

},

)

.map(|((this, _), _)| match this.error {

Some(err) => Err(StructWalkError { kind: err }),

None => Ok(()),

})

// E::ready(self).as_ctx_for::<'ctx, '_>(|this, _| {

// (RecoverableScope::<'ctx, E>::new_walk::<'_, 'b, '_>(this, visitor), PhantomData)

] where

E: Effect,

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

I::T: 'static

}

&'a mut self,

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

) -> ErasedEffective<'a, Result<MetaKnown<'a, 'ctx, RecoverableProto<E>>, ()>, E> {

}

}

E::ready(Ok(TagKnown {

kind_available: Some(true),

}))

}

}

E::ready(Ok(TagKnown {

kind_available: Some(true),

}))

}

}

E::ready(Ok(TagKnown {

kind_available: Some(true),

}))

}

}

E::ready(Ok(TagKnown {

kind_available: Some(true),

}))

}

}

E::ready(Ok(TagKnown {

kind_available: Some(true),

}))

}

}

'ctx,

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

>::hint(self, visitor, TagHint { kind: TagConst }),

}

}

kind_available: Some(false),

}),

})

}

}

&'a mut self,

_hint: &'a (),

) -> ErasedEffective<'a, Result<ValueKnown<'a, BorrowedStatic<'ctx, I::T>>, ()>, E> {

}

}

E::ready(Ok(SequenceKnown {

len: (len, Some(len)),

}))

}

}

where

E: Effect,

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

fn size_hint(&mut self) -> ErasedEffective<'_, (usize, Option<usize>), E> {

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

}

#[inline(always)]

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

}

let index = self.index;

self.index += 1;

// E::map(

// I::walk_field::<E>(index, self.value, visitor),

}

}

where

E: Effect,

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

#[inline(always)]

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

&'a mut self,

) -> ErasedEffective<'c, Status, E> {

// Reset the errors to default state.

self.error = None;

// Reset the field index to the default.

self.index = 0;

)

)

}

}

&'static T: Into<W>,

{

#[inline(always)]

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

self.current += 1;

todo!()

// }

// })

} else {

}

}

#[inline(always)]

fn size_hint(&mut self) -> ErasedEffective<'_, (usize, Option<usize>), E> {

}

}

use crate::{

any::{BorrowedStatic, OwnedStatic},

never::Never,

protocol::{visitor::visit_value, DynVisitor},

WalkerTypes,

visitor: DynVisitor<'b, 'ctx>,

) -> ErasedEffective<'c, Result<Self::Output, Self::Error>, E> {

// Attempt to visit using the value protocol.

// E::map(

// visit_value::<_, E>(visitor, OwnedStatic(self.0)),

// |_| Ok(()),

b: builders.b.build().into_future().await.unwrap(),

})

})

}

#[inline(always)]

b: Builder::<E>::from_seed(()).into_future().await,

}

})

}

}

pub struct X {

pub a: bool,

pub b: bool,

}

pub struct Y {

pub b: bool,

pub a: bool,

}

#[no_mangle]

pub fn ident(x: X) -> Y {

other.0.unwrap()

}

}

where

Self: 'a,

{

}

fn build<'a>(self) -> ErasedEffective<'a, Result<Self::Value, Self::Error>, E>

where

Self: 'a,

{

}

fn as_visitor(&mut self) -> DynVisitor<'_, 'ctx> {

visitor: DynVisitor<'a, 'ctx>,

hint: MetaHint<'a, 'ctx, P>,

) -> ErasedEffective<'a, Flow, P::Effect> {

}

fn known<'a>(

&'a mut self,

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

) -> ErasedEffective<'a, Result<MetaKnown<'a, 'ctx, P>, ()>, P::Effect> {

}

}

&'a mut self,

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

) -> ErasedEffective<'a, VisitResult<DynRecoverableScope<'a, 'ctx, E>>, E> {

}

}

&'a mut self,

visitor: DynVisitor<'b, 'ctx>,

) -> ErasedEffective<'c, Status, E> {

}

}

&'a mut self,

walker: DynWalker<'a, 'ctx>,

) -> ErasedEffective<'a, VisitResult<DynWalker<'a, 'ctx>>, E> {

}

}

}

impl<'ctx, E: Effect> Sequence<'ctx, E> for MockSequenceVisitor<E> {

&'a mut self,

}

}

mock! {

pub SequenceScope<E> {

pub fn size_hint(&mut self) -> (usize, Option<usize>);

}

}

impl<'ctx, E: Effect> SequenceScope<'ctx, E> for MockSequenceScope<E> {

fn size_hint(&mut self) -> ErasedEffective<'_, (usize, Option<usize>), E> {

}

}

}

VisitResult::Skipped(_) => VisitResult::Skipped(walker),

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

})

}

}

VisitResult::Skipped(_) => VisitResult::Skipped(value),

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

})

}

}

where

Self: 'c,

{

}

}

visitor::{Recoverable, ValueProto, VisitResult},

DynVisitor,

},

};

use crate::common::{

visitor.expect_traits().times(2).return_const(None);

// Attempt to walk once.

// Attempt to walk twice.

// We are done.

VisitResult::Control(Flow::Done)

.upcast::<ValueProto<OwnedStatic<i32>, Blocking>>()

.is_none());

});

// Visit using the recoverable protocol.

_ => Ok(Flow::Done),

}

})

}

}