checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]

name = "downcast"

version = "0.11.0"

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

name = "effectful"

version = "0.1.0"

dependencies = [

"effectful-derive",

"mini-macro-magic",

]

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

"cfg-if",

"proc-macro2",

"quote",

]

[[package]]

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

]

[[package]]

name = "proc-macro2"

version = "1.0.86"

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.68"

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

checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"

dependencies = [

"proc-macro2",

"quote",

]

[[package]]

checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

[[package]]

name = "wait-timeout"

version = "0.2.0"

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

pub use static_wrapper::*;

pub use type_name_id::*;

&'a self,

id: WithLtTypeId<'lt, 'ctx>,

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

where

{

let _id = id;

None

}

&'a mut self,

id: WithLtTypeId<'lt, 'ctx>,

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

where

{

let _id = id;

None

}

}

#[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>())

$this:ident,

$id:ident,

{

}

} => {{

match $id {

$(

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

}

)*

}

}};

{

$this:ident,

$id:ident,

{

}

} => {{

match $id {

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

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

}=> {

}

)*

}

}};

}

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

pub mod builders;

use crate::protocol::AsVisitor;

///

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

}

type Seed: DynBind<C>;

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

/// 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 effectful::{

SendSync,

};

// pub mod variant;

pub mod r#enum;

pub mod tag_name;

#[derive(Default, SendSync)]

}

}

impl NoopVisitor {

E::value(NoopVisitor::new())

walker

.walk(DynVisitor(noop))

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

macro_rules! value_builder {

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

where

{

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

})*

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

use effectful::bound::Dynamic;

use effectful::SendSync;

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

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

};

#[derive(SendSync)]

where

{

}

#[derive(SendSync)]

where

{

Temp,

Seed(Info::Seed),

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

}

type Builders: DynBind<E>;

type Seed: DynBind<E>;

fn new_builder<'a>(

seed: Self::Seed,

variant: Self::VariantMarker,

fn finish_builder<'a>(

builder: Self::Builders,

where

Dynamic<Self::T>: DynBind<E>;

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

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

fn guess_variant<'a>(

seed: Self::Seed,

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

where

Dynamic<Self::T>: DynBind<E>;

}

where

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

{

type Seed = Info::Seed;

}

}

where

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

{

where

Self: 'a,

{

.cast()

}

where

Self: 'a,

{

}

}

where

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

{

DynVisitor(self)

}

}

where

E: Environment,

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

// }

where

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

{

fn visit<'a>(

&'a mut self,

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

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

Inner::Seed(seed) => Info::guess_variant(seed, scope)

.map(self, |this, result| {

}

}

where

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

{

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

&'this mut self,

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

where

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

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

}

}

where

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

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

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

{

&'a mut self,

_kind: tags::Variant,

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

}

}

#[derive(SendSync)]

where

{

marker: Option<Info::VariantMarker>,

}

where

E: Environment,

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

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

{

// fn visit<'a>(

// &'a mut self,

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

// where

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

// 'ctx: 'a,

// }

// }

where

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

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

{

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

&'this mut self,

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

where

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

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

use effectful::{

bound::Dynamic,

};

use crate::{

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

build::BuilderTypes,

hkt::Marker,

/// A builder for a struct.

#[derive(SendSync)]

where

{

}

#[derive(SendSync)]

where

{

Temp,

Seed(Info::Seed),

///

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

type Builders: DynBind<E>;

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,

where

Dynamic<Self::T>: DynBind<E>;

fn as_visitor<'a>(

marker: Self::FieldMarker,

builders: &'a mut Self::Builders,

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

///

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

#[derive(SendSync)]

where

{

/// Error from the struct info definition.

error: Info::Error,

}

where

{

fn from_field_err(error: Info::Error) -> Self {

Self { error }

}

}

where

{

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

f.debug_tuple("StructError").field(&self.error).finish()

}

}

where

{

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

Display::fmt(&self.error, f)

}

}

where

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

{

type Seed = Info::Seed;

type Output = Dynamic<Info::T>;

}

}

where

Self: DynBind<E>,

{

where

'ctx: 'e,

{

}

}

where

Self: DynBind<E>,

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

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

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

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

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

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

{

where

Self: 'a,

{

.cast()

}

where

Self: 'a,

{

}

}

where

Self: DynBind<E>,

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

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

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

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

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

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

{

DynVisitor(self)

}

}

where

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

E: Environment,

Self: DynBind<E>,

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

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

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

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

Mode: 'ctx,

{

}

// any_trait! {

// Mode: 'ctx,

// }

where

Self: DynBind<E>,

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

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

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

E: Environment,

{

#[inline(always)]

&'this mut self,

where

'ctx: 'this + 'walker,

{

E::value((self, walker))

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

// struct value.

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

/// Allows for a walker to directly give the struct value.

///

/// This skips needing to go through each field individually.

where

Self: DynBind<E>,

E: Environment,

{

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

&'this mut self,

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

where

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

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

/// Allows for the walker to use field names.

///

/// By default [`StructBuilder`] expects a tuple-like struct.

where

Self: DynBind<E>,

E: Environment,

{

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.

E::value(self)

.then(walker, |walker, (this, _)| {

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

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

/// Allows for the walker to use field names.

///

/// By default [`StructBuilder`] expects a tuple-like struct.

where

Self: DynBind<E>,

E: Environment,

{

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.

E::value(self)

.then(walker, |walker, (this, _)| {

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

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

///

/// If the [`tags::Struct`] or [`tags::Map`] tags are used then this will expect

/// a sequence of key value pairs. Where the key is the field name.

where

Self: DynBind<E>,

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

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

Dynamic<OwnedStatic<String>>: DynBind<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.

E::value(self)

match &mut this.inner {

// We should treat the sequence as just values.

Inner::Builders {

.next(visitor)

.map((), |_, x| Flow::to_control_flow(x))

.cast()

.cast::<()>()

}

// We should treat the sequence as key value pairs.

.next(DynVisitor(visitor))

.map((), |_, x| Flow::to_control_flow(x))

.cast()

.cast()

}

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

}

#[derive(SendSync)]

builders: &'a mut I::Builders,

marker: Option<I::FieldMarker>,

_marker: Marker<E>,

}

where

E: Environment,

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! {

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

// }

where

E: Environment,

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

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

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

&'a mut self,

_key: tags::Key,

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

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

field_marker: None,

_marker: Default::default(),

};

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

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

})

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

}

#[derive(SendSync)]

field_marker: Option<I::FieldMarker>,

_marker: Marker<E>,

}

where

E: Environment,

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

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

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

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

// }

where

E: Environment,

{

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

&'this mut self,

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

where

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

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

// fn visit<'a>(

// &'a mut self,

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

// where

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

// 'ctx: 'a,

// }

// }

where

E: Environment,

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

{

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

&'this mut self,

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

'e,

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

E,

}

}

where

E: Environment,

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

{

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

&'this mut self,

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

'e,

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

E,

use effectful::{

bound::Dynamic,

SendSync,

};

}

}

where

Dynamic<T>: DynBind<E>,

{

where

Self: 'a,

{

E::value(self.value.ok_or(ValueError(Default::default()))).cast()

}

where

Self: 'a,

{

}

}

where

{

DynVisitor(self)

}

}

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

{

&'a mut self,

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

where

{

trait_by_id!(&mut self, id, {

}

}

where

Dynamic<T>: DynBind<E>,

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

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

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

{

&'a mut self,

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

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

where

{

dbg!(&id);

trait_by_id!(&mut self, id, {

}

}

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

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

{

&'this mut self,

where

'ctx: 'this + 'walker,

{

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

})

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

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

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

{

&'this mut self,

where

'ctx: 'this + 'walker,

{

E::value((self, walker))

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

.cast()

})

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

&'this mut self,

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

where

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

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

'ctx,

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

>,

'e,

VisitResult<

Dynamic<

// fn visit<'a>(

// &'a mut self,

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

// where

// 'ctx: 'a,

// {

// fn visit<'a>(

// &'a mut self,

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

// where

// 'ctx: 'a,

// {

// fn visit<'a>(

// &'a mut self,

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

// where

// 'ctx: 'a,

// {

// add a module here to seal fields.

impl<'ctx, M: 'ctx, E: effectful::environment::Environment> $crate::Build<'ctx, M, E> for $name

where

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

$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>;

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

where

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

{

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

type FieldMarker = Field;

};

#[inline(always)]

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

use effectful::effective::Effective;

).map((), |_, ($($field,)*)| {

Builders {

$($field),*

.cast()

}

use $crate::Builder;

use effectful::effective::Effective;

use $crate::build::BuilderTypes;

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

Ok(($(effectful::bound::Dynamic($field),)*)) => Ok(effectful::bound::Dynamic($name {

$($field),*

// add a module here to seal fields.

impl<'ctx, M: 'ctx, E: effectful::environment::Environment> $crate::Build<'ctx, M, E> for $name

where

$($value: $crate::Build<'ctx, M, E>,)*

$(<<$value as Build<'ctx, M, E>>::Builder as BuilderTypes<E>>::Seed: Default,)*

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

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

where

$($value: $crate::Build<'ctx, M, E>,)*

$(<<$value as Build<'ctx, M, E>>::Builder as BuilderTypes<E>>::Seed: Default),*

{

fn new_builder<'a>(

seed: Self::Seed,

variant: Self::VariantMarker,

match variant {

$(__Marker::$variant => {

Builder::<E>::from_seed(Default::default()).map((), |_, builder| __Builders::$variant(builder)).cast()

fn finish_builder<'a>(

builder: Self::Builders,

match builder {

$(__Builders::$variant(builder) => builder.build().map((), |_, value| value.map(|x| effectful::bound::Dynamic($name::$variant(<<$value as Build<'ctx, M, E>>::Builder as BuilderTypes<E>>::unwrap_output(x)))).map_err(__Error::$variant)).cast()),*

}

}

value.0

}

fn guess_variant<'a>(

seed: Self::Seed,

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

use effectful::short::ResultErrorExt;

E::value((scope, Err(__ErrorBuilder::<M, E> { A: None, B: None })))

<<$value as Build<M, E>>::Builder as Builder<_>>::from_seed(Default::default())

.map(scope, |scope, builder| (scope, builder))

.then((), |(), ((_, builder), _)| builder.build())

.map(error, |mut error, result| {

result.map(|x| effectful::bound::Dynamic(X::$variant(

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

use crate::any::AnyTrait;

}

where

{

self

}

self

}

}

#[derive(SendSync)]

}

}

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

self.0.cast()

}

}

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

self.0.cast_mut()

}

}

}

self.cast()

}

}

#[derive(SendSync)]

}

}

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

self.0.cast()

}

}

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

self.0.cast_mut()

}

use crate::{Flow, Status};

mod recoverable;

mod value;

use effectful::{

};

pub use recoverable::*;

pub use request_hint::*;

}

}

'wrap,

'lt,

(),

Cap,

&'a mut Update,

)

>,

),

Update,

VisitResult<()>,

Eff,

>;

for<'a> fn(

Cap,

&'a mut Update,

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

fn if_skipped<'ctx, 'wrap, Cap, Update>(

'ctx: 'lt,

'lt: 'wrap,

{

(),

},

)

}

'ctx: 'lt,

'lt: 'wrap,

{

(),

},

)

}

}

use effectful::{

};

use crate::{

fn visit<'a>(

&'a mut self,

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

}

const _: () = {

};

pub trait RecoverableScope<'ctx, E: Environment>: DynBind<E> {

&'this mut self,

}

pub type DynRecoverableScope<'a, 'ctx, E> = &'a mut (dyn RecoverableScope<'ctx, E> + 'a);

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

if let Some(object) = visitor

.0

.cast_mut()

{

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

object.visit(scope)

use effectful::{

};

use crate::{

///

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

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

&'this mut self,

where

'ctx: 'this + 'walker;

}

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

E::value((visitor, walker))

if let Some(object) = visitor

.0

.cast_mut()

use effectful::{

};

use crate::{

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

&'a mut self,

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

where

'ctx: 'a;

}

};

pub trait SequenceScope<'ctx, E: Environment>: DynBind<E> {

&'a mut self,

where

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

}

}

#[inline(always)]

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

if let Some(object) = visitor

.0

.cast_mut()

{

// Allow the visitor to walk the sequence scope.

object.visit(scope)

use core::any::TypeId;

use effectful::{

};

use crate::{

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

}

fn symbol(&self) -> Symbol;

}

const NEW: Self;

}

const NEW: Self = TagConst;

}

#[derive(Copy, Clone, SendSync)]

pub struct TagDyn(pub Symbol);

fn symbol(&self) -> Symbol {

Symbol::from_int(SYMBOL)

}

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

}

fn symbol(&self) -> Symbol {

self.0

}

}

pub trait Tag<'ctx, K: TagKind<E>, E: Environment>: DynBind<E> {

&'a mut self,

kind: K,

}

const _: () = {

}

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,

pub fn visit_tag<

'ctx: 'visitor,

'visitor: 'wrap,

'wrap,

K: TagKind<E>,

E: Environment,

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);

// Give everything to the effective chain to be used as context.

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

// Try to visit the tag kind as given.

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

.visit(*kind, walker)

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

use effectful::{

};

use crate::{

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

&'this mut self,

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

where

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

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

pub fn visit_value<

'ctx: 'visitor,

'visitor: 'e,

'e,

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

E: Environment,

>(

value: T,

where

Dynamic<T>: DynBind<E>,

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

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

use effectful::{

};

use crate::{

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

///

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

&'this mut self,

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

where

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

fn known<'a>(

&'a mut self,

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

where

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

}

#[derive(SendSync)]

_marker: Marker<Protocol>,

}

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

where

{

Self {

visitor: DynVisitor(visitor),

}

}

self.visitor

.unwrap()

}

self.visitor

}

}

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

&self.visitor

}

}

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

&mut self.visitor

}

'walker: 'e,

'visitor: 'e,

'hint: 'e,

'e,

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

E,

T,

>(

visitor: &'visitor mut T,

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

where

E: Environment,

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

{

if let Some(object) = walker

.0

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

{

object

use effectful::{

};

use futures::Future;

#[allow(clippy::type_complexity)]

pub fn transform<

'a,

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

E: Environment,

>(

seed: B::Seed,

walker: W,

B::from_seed(seed)

walker.walk(builder.as_visitor()).cast()

})

.then((), |_, (builder, walker_result)| {

pub trait BuildExt {

/// Build a value of this type using the default builder.

#[allow(clippy::type_complexity)]

walker: W,

) -> Result<

Self,

BuildError<

>,

>

where

{

(Ok(value), _) => Ok(Self::Builder::unwrap_output(value)),

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

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

}

}

walker: W,

) -> impl Future<

Output = Result<

Self,

BuildError<

>,

>,

> + Send

where

{

async {

let walker = walker;

.await

{

(Ok(value), _) => Ok(Self::Builder::unwrap_output(value)),

}

}

where

{

}

}

pub trait WalkExt {

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

&'a self,

where

{

}

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

&'a self,

where

{

}

#[allow(clippy::result_unit_err)]

where

{

let mut builder = builder;

let _ = Walk::into_walker(self)

.walk(builder.as_visitor());

Ok(value) => Ok(B::unwrap_output(value)),

_ => todo!(),

}

use core::fmt::Debug;

use effectful::{

};

use crate::{protocol::DynVisitor, Flow};

type Walker: Walker<'ctx, E>;

#[must_use]

where

Self: 'e;

}

/// Walk the value.

///

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

self,

where

Self: 'effect;

}

&'a mut self,

where

Self: 'a;

}

#[derive(SendSync)]

enum DynWalkerState<'ctx, W: Walker<'ctx, E>, E: Environment> {

}

}

for DynWalkerAdapter<'ctx, W, E>

where

Self: DynBind<E>,

{

#[inline(always)]

&'a mut self,

where

Self: 'a,

{

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

{

E::value((self, visitor))

// Walk the walker.

walker

.walk(visitor.cast())

use effectful::{

bound::Dynamic,

};

use crate::{any::OwnedStatic, Walk};

{

type Walker = ValueWalker<bool>;

E::value(ValueWalker::new(self)).cast()

}

}

{

type Walker = ValueWalker<bool>;

E::value(ValueWalker::new(*self)).cast()

}

}

use effectful::bound::Dynamic;

use effectful::effective::Effective;

use crate::{

any::AnyTrait,

type Output = Dynamic<T>;

self,

where

Self: 'effect,

{

let value = self.value;

E::value((self, visitor))

request_hint::<E>(visitor.cast(), DynWalker(this))

.map((), |_, x| VisitResult::unit_skipped(x))

.cast()

{

}

where

T: Integer,

E: Environment,

Dynamic<OwnedStatic<$type>>: DynBind<E>,

for<'a> Dynamic<&'a OwnedStatic<$type>>: DynBind<E>

{

&'this mut self,

_hint: (),

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a (),

where

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

{

use effectful::{

SendSync,

};

type Output = ();

#[inline(always)]

self,

let Self {

key_walker,

value_walker,

} = self;

E::value(visitor)

visit_tag::<tags::Key, E, _>(TagConst, visitor.cast(), key_walker)

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

Ok(visit) => visit.unit_skipped(),

use effectful::{

SendSync,

};

type Output = ();

self,

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

}

}

use effectful::{

bound::Dynamic,

higher_ranked::{for_lt, Rank1, WithLt},

SendSync,

};

use crate::{

type T: DynBind<E>;

/// Walk the given field.

index: usize,

value: &'ctx Self::T,

}

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

}

}

where

E: Environment,

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

{

type Error = StructWalkError<I::FieldError>;

type Output = ();

#[inline(always)]

self,

where

Self: 'c,

{

E::value((self, visitor))

})

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

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

pub enum StaticType {}

where

E: Environment,

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

// ] where

// }

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

where

E: Environment,

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

{

#[inline(always)]

&'this mut self,

_visitor: DynVisitorWith<

'visitor,

'ctx,

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

>,

_hint: (),

where

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

{

fn known<'a>(

&'a mut self,

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

where

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

{

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

// >,

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

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

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

// {

// &'this mut self,

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

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

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

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

// {

// &'this mut self,

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

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

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

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

// {

// &'this mut self,

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

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

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

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

// {

// &'this mut self,

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

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

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

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

// {

// &'this mut self,

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

// _hint: TagHint<TagDyn>,

// where

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

// {

// fn known<'a>(

// &'a mut self,

// hint: &'a WithLt<'a, Rank1<TagHint<TagDyn>>>,

// where

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

// {

// &'this mut self,

// _visitor: DynVisitorWith<'visitor, 'ctx, dyn Value<'ctx, BorrowedStatic<'ctx, I::T>, E> + 'x>,

// _hint: (),

// where

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

// {

// fn known<'a>(

// &'a mut self,

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

// where

// WithLt<'a, Rank1<ValueKnown<'a, BorrowedStatic<'ctx, I::T>>>>: DynBind<Protocol::Env>

// {

{

#[inline(always)]

&'this mut self,

visitor: DynVisitorWith<

'visitor,

'ctx,

type_name::Raised<'static, 'ctx, dyn Sequence<'ctx, E>>,

>,

_hint: SequenceHint,

where

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

{

visitor

.as_known()

.visit(*this)

fn known<'a>(

&'a mut self,

hint: &'a WithLt<'a, Rank1<SequenceHint>>,

where

WithLt<'a, Rank1<SequenceKnown>>: DynBind<E>,

{

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

{

#[inline(always)]

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

E::value((len, Some(len))).cast()

}

#[inline(always)]

&'a mut self,

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

return E::value(Flow::Done).cast();

}

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

{

#[inline(always)]

&'a mut self,

// Reset the errors to default state.

self.error = None;

self.index = 0;

E::value((self, visitor))

request_hint::<E>(visitor.cast(), DynWalker(*this))

.map((), |_, x| VisitResult::unit_skipped(x))

.cast()

use effectful::{

bound::IsSync,

SendSync,

};

type Output = ();

#[inline(always)]

self,

todo!()

// E::wrap(async move {

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

}

}

// any_trait! {

// impl['a, 'ctx, T, W][E] StaticSliceWalker<T, W> = [

&'static T: Into<W>,

{

#[inline(always)]

&'a mut self,

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

self.current += 1;

todo!()

}

#[inline(always)]

E::value((self.names.len(), Some(self.names.len()))).cast()

}

}

use effectful::{

bound::Dynamic,

SendSync,

};

type Output = ();

#[inline(always)]

self,

// Attempt to visit using the value protocol.

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

.map((), |_, _| Ok(()))

type Output = Dynamic<&'ctx T>;

#[inline(always)]

self,

// Attempt to visit using the value protocol.

E::value((self, visitor))

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

.map((), |_, x| VisitResult::unit_skipped(x))

.cast()

use crate::walk::walkers::core::noop::NoopWalker;

use effectful::{

higher_ranked::{Rank1, WithLt},

SendSync,

};

use serde::{

de::{DeserializeSeed, MapAccess},

impl<'ctx, T, E: Environment> Walker<'ctx, E> for DeserializerWalker<'ctx, T, E>

where

T: Deserializer<'ctx>,

{

type Error = DeserializerWalkerError<'ctx, T>;

type Output = ();

self,

where

Self: 'effect,

{

E::value((self, visitor))

// Serde deserializers usually prefer that a hint method is called rather than _any.

// As such we need to ask the visitor for a hint first.

request_hint::<E>(visitor.cast(), DynWalker(this))

}

}

where

T: Deserializer<'ctx>,

E: Environment<NeedSend = No, NeedSync = No>,

impl<'ctx, T, E: Environment> DeserializerWalker<'ctx, T, E>

where

T: Deserializer<'ctx>,

{

#[allow(clippy::type_complexity)]

fn call_deserialize<'this: 'e, 'e, Cap>(

Cap,

T,

) -> Result<

T::Error,

>,

where

'ctx: 'this,

Cap: DynBind<E> + 'e,

$(impl<$ctx, $T, $E: Environment> Hint<$ctx, type_name::Raised<'static, $ctx, $proto>> for DeserializerWalker<$ctx, $T, $E>

where

$T: Deserializer<$ctx>,

{

&'this mut self,

_hint: WithLt<'hint, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Hint>,

where

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

{

$E::value((self, visitor))

this.call_deserialize(visitor, move |visitor, deserializer| {

let x = deserializer.$method(Visitor::<$T, $E>::new(visitor.cast(), stringify!($type)));

x.map(|x| x.cast())

fn known<'a>(

&'a mut self,

_hint: &'a WithLt<'a, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Hint>,

where

WithLt<'a, <type_name::Raised<'static, $ctx, $proto> as HintMeta>::Known>: DynBind<$E>

{

for DeserializerWalker<'ctx, T, E>

where

T: Deserializer<'ctx>,

{

&'this mut self,

_visitor: DynVisitorWith<

'visitor,

'ctx,

type_name::Raised<'static, 'ctx, dyn Tag<'ctx, tags::Map, E>>,

>,

_hint: TagHint<tags::Map>,

where

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

{

fn known<'a>(

&'a mut self,

_hint: &'a WithLt<'a, Rank1<TagHint<tags::Map>>>,

where

WithLt<'a, Rank1<TagKnown>>: DynBind<E>,

{

}

#[derive(SendSync)]

where

T: Deserializer<'ctx>,

{

wanted: &'static str,

_marker: Marker<(T, E)>,

}

where

T: Deserializer<'ctx>,

{

Self {

wanted,

visitor,

};

}

where

{

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

formatter.write_str(self.wanted)

where

A: MapAccess<'ctx>,

{

// Need to notify the visitor we are doing a map instead of just a sequence.

visit_sequence(this.visitor.cast(), scope).cast()

});

impl<'ctx, A, E: Environment> SequenceScope<'ctx, E> for MapScope<A>

where

A: MapAccess<'ctx>,

{

E::value((0, self.map.0.size_hint())).cast()

}

&'a mut self,

where

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

{

}

}

}

where

{

type Value = ();

}

}

}

where

{

type Value = ();

tag::TagVisitorExt as _,

value::ValueVisitorExt as _,

},

};

use effectful::{

SendSync,

};

use effectful::SendSync;

use macro_rules_attribute::derive;

use treaty::{

any::{OwnedStatic, TempBorrowedStatic},

use crate::common::{

protocol::{sequence::MockSequenceScope, value::ValueVisitorExt as _},

walker::MockWalker,

};

mod common;

let mut scope;

{

// A tuple-like struct is just a sequence.

// First field.

scope.expect_next().once().returning(|mut visitor| {

let mut scope;

{

// A map is a sequence of keyed values.

// Here we do the b field first to show a map-like doesn't care about order.

scope.expect_next().once().returning(|mut visitor| {

let mut walker;

{

// We need to give the b field name in the key tag.

walker.expect_walk().once().returning(|mut visitor| {

// Tag the value with a key as the field name.

assert_eq!(

Ok(VisitResult::Control(Flow::Continue)),

);

scope.expect_next().once().returning(|mut visitor| {

let mut walker;

{

// Here we do field a.

walker.expect_walk().once().returning(|mut visitor| {

// Tag the value with a key.

assert_eq!(

Ok(VisitResult::Control(Flow::Continue)),

);

// We need to provide the map tag to the struct before getting into the sequence.

// This tag notifies the struct builder to expect the sequence as a map.

assert_eq!(

.into_value(),

Ok(VisitResult::Control(Flow::Continue))

);

mod common;

use common::walker::MockWalker;

use treaty::{

any::{type_name, BorrowedStatic, OwnedStatic, TempBorrowedStatic},

use crate::common::{

protocol::{hint::MockHintWalker, value::ValueVisitorExt as _},

};

#[test]

// Expect the value builder to hint the value protocol with a owned i32.

let mut walker = MockHintWalker::<

>::new();

walker.expect_hint().once().returning(|mut visitor, ()| {

// Fulfill the hint by visiting with a i32 value.

// Request a hint from the i32 builder for what protocol to use.

assert_eq!(

Flow::Done.into()

);

fn value_builder_can_use_an_owned_value_or_a_borrowed_value() {

assert_eq!(

i32::build({

walker.expect_walk().once().returning(|mut visitor| {

visitor.visit_value_and_done(OwnedStatic(1));

Ok(())

assert_eq!(

i32::build({

walker.expect_walk().once().returning(|mut visitor| {

visitor.visit_value_and_done(BorrowedStatic(&2));

Ok(())

assert_eq!(

i32::build({

walker.expect_walk().once().returning(|mut visitor| {

visitor.visit_value_and_done(TempBorrowedStatic(&3));

Ok(())

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

use effectful::{

forward_send_sync, SendSync,

};

use mockall::mock;

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

}

}

impl<Seed, Value, Error: Display + Debug, E: Environment> BuilderTypes<E>

for MockBuilder<Seed, Value, Error, E>

}

}

Builder<'ctx, E> for MockBuilder<Seed, Value, Error, E>

where

Dynamic<Value>: DynBind<E>,

{

where

Self: 'a,

{

E::value(Self::from_seed(seed)).cast()

}

where

Self: 'a,

{

}

}

for MockBuilder<Seed, Value, Error, E>

where

Seed: DynBind<E>,

sync::{Mutex, MutexGuard, OnceLock, RwLock},

};

pub mod builder;

pub mod protocol;

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

higher_ranked::WithLt,

};

}

}

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

&'a mut self,

id: WithLtTypeId<'lt, 'ctx>,

'ctx: 'lt,

{

trait_by_id!(&mut self, id, {

}

}

// P: HintMeta<Effect = E>,

// }

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

&'this mut self,

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

hint: WithLt<'hint, <P as HintMeta>::Hint>,

where

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

{

fn known<'a>(

&'a mut self,

hint: &'a WithLt<'a, <P as HintMeta>::Hint>,

where

{

todo!()

}

// &'this mut self,

// visitor: DynVisitorWith<'visitor, 'ctx, P>,

// hint: WithLt<'hint, P>,

// where

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

// {

// fn known<'a>(

// &'a mut self,

// hint: &'a WithLt<'a, P::Hint>,

// P::Effect::value(Self::known(self)(&(), hint)).cast()

// }

}

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

Flow, Status,

};

mock! {

pub RecoverableVisitor<E: Environment> {

pub fn visit<'a, 'ctx>(&mut self, scope: DynRecoverableScope<'a, 'ctx, E>) -> VisitResult;

}

}

// any_trait! {

// impl['ctx][E] MockRecoverableVisitor<E> = [

// E: Environment,

// }

fn visit<'a>(

&'a mut self,

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

E::value(self.visit(scope)).cast()

}

}

}

}

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

&'a mut self,

visitor: DynVisitor<'b, 'ctx, E>,

E::value(self.new_walk(visitor)).cast()

}

}

pub trait RecoverableVisitorExt<'ctx> {

}

impl<'ctx, T> RecoverableVisitorExt<'ctx> for T

where

{

fn visit_recoverable_and_done<'a>(

&'a mut self,

) {

assert_eq!(result, VisitResult::Control(Flow::Done));

}

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

}

}

// any_trait! {

// impl['ctx][E] MockRequestHintVisitor<E> = [

// E: Environment,

// }

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

&'this mut self,

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

where

'ctx: 'this + 'walker,

{

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

}

}

// any_trait! {

// impl['ctx][E] MockSequenceVisitor<E> = [

// E: Environment,

// }

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

&'a mut self,

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

E::value(self.visit(scope)).cast()

}

}

}

}

E::value(self.size_hint()).cast()

}

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

&'a mut self,

visitor: DynVisitor<'b, 'ctx, E>,

E::value(self.next(visitor)).cast()

}

}

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

Flow, Walker,

};

mock! {

pub TagVisitor<K: TagKind<E>, E: Environment> {

pub fn visit<'a, 'ctx>(&'a mut self, kind: K, walker: DynWalkerObjSafe<'a, 'ctx, E>) -> VisitResult;

}

}

// any_trait! {

// impl['ctx, K][E] MockTagVisitor<K, E> = [

// E: Environment,

// }

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

&'a mut self,

kind: K,

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

E::value(self.visit(kind, walker)).cast()

}

}

pub trait TagVisitorExt<'ctx> {

&'a mut self,

walker: W,

);

impl<'ctx, T> TagVisitorExt<'ctx> for T

where

{

&'a mut self,

walker: W,

) {

let result =

assert_eq!(result.unwrap(), VisitResult::Control(Flow::Done));

}

use effectful::{

bound::{Bool, Dynamic, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

Flow,

};

mock! {

pub ValueVisitor<T: type_name::Static>

where

}

}

for<'a, 'ctx> type_name::Lowered<'a, 'ctx, T>: Sized

});

// E: Environment,

// }

where

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

where

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

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

// fn visit<'a>(

// &'a mut self,

// value: TypeName::T<'a, 'ctx, T, E>,

// where

// 'ctx: 'a,

// {

impl<'ctx, U> ValueVisitorExt<'ctx> for U

where

{

#[track_caller]

fn visit_value_and_done<'a, T>(&'a mut self, value: T)

type_name::Raised<'a, 'ctx, T>: type_name::Static,

'ctx: 'a,

{

assert_eq!(result, VisitResult::Control(Flow::Done));

}

// #[track_caller]

// fn visit_value_and_done<'a, T>(&'a mut self, value: T)

// where

// 'ctx: 'a,

// {

//

// assert_eq!(result, VisitResult::Control(Flow::Done));

// }

// #[track_caller]

// fn visit_value_and_skipped<'a, T>(&'a mut self, value: T)

// where

// 'ctx: 'a,

// {

//

// assert_eq!(result.unit_skipped(), VisitResult::Skipped(()));

// }

use effectful::{

bound::{Bool, IsSend, IsSync},

forward_send_sync,

};

use mockall::mock;

}

}

for MockWalker<Output, Error, E>

{

type Error = Error;

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

self,

visitor: DynVisitor<'a, 'ctx, E>,

where

Self: 'c,

{

use common::protocol::recoverable::MockRecoverableVisitor;

use treaty::{

any::OwnedStatic,

protocol::{

};

use crate::common::{

};

mod common;

/// Tests that the recoverable protocol allows multiple walks by the visitor.

#[test]

fn recoverable_can_be_visited() {

// Expect a visit using the rescoverable protocol.

mock.expect_visit().once().returning(|scope| {

// Expect that the visitor gets used.

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

VisitResult::Control(Flow::Done)

});

let mut scope = MockRecoverableScopeVisitor::new();

scope.expect_new_walk().times(2).returning(|visitor| {

// Attempt to use the visitor.

assert!(visitor

.is_none());

Status::Ok

use std::any::TypeId;

use common::{

protocol::{hint::MockHintWalker, request_hint::MockRequestHintVisitor},

walker::MockWalker,

Flow,

};

use effectful::bound::Dynamic;

mod common;

#[test]

fn hints_can_be_requested() {

// We will request a hint from the visitor.

mock.expect_request_hint().once().returning(|mut walker| {

// Lookup the value protocol on the walker.

let obj = walker

.unwrap();

// Get the known for the value protocol.

});

// This mock becomes the visitor.

// The visitor will lookup the value protocol on the walker.

mock.expect_traits_mut()

.once()

.with(eq(TypeNameId::of::<

>()))

.returning(|_id| {

// Expect to give a known for the value protocol to the visitor.

mock.expect_known().once().return_const(

Ok(ValueKnown {

preview: Some(Dynamic(&OwnedStatic(42))),

})

);

Some(Box::new(mock))

#[test]

fn request_hint_proto() {

// The type id of the higher ranked type.

// The type id for the lifetime containing value protocol trait object.

// They should be the same.

assert_eq!(id, name_id.into_type_id());

use std::any::TypeId;

use common::protocol::sequence::{MockSequenceScope, MockSequenceVisitor};

use treaty::{

Flow,

};

mod common;

#[test]

fn sequence_has_scope_with_size_hint_and_next() {

// Expect a visit with the sequence protocol.

mock.expect_visit().once().returning(|scope| {

// Get the size hint from the sequence scope.

assert_eq!(scope.size_hint().into_value(), (1, Some(1)));

// Expect the walker to lookup a trait.

visitor.expect_traits().once().return_const(None);

});

// Everything goes throw the sequence protocol trait.

// Expect a size hint to be asked for.

scope.expect_size_hint().once().return_const((1, Some(1)));

scope.expect_next().once().returning(|visitor| {

// Attempt to lookup a trait on the visitor.

assert!(visitor

.is_none());

// We are done.

#[test]

fn sequence_proto() {

// The type id of the higher ranked type.

// The type id for the lifetime containing value protocol trait object.

// They should be the same.

assert_eq!(id, name_id.into_type_id());

use std::any::TypeId;

use common::protocol::tag::MockTagVisitor;

use treaty::{

protocol::{

DynVisitor,

},

symbol::Symbol,

Flow,

};

mod common;

/// Tests that the tag protocol can be visited with a value walker.

#[test]

fn tag_can_be_visited() {

// Expect a visit with the tag protocol.

mock.expect_visit()

// The kind should be test.

assert_eq!(kind, Symbol::new("test"));

// Expect that the builder is attempted to be used by the walker for the value.

// Walk the value of the tag.

assert_eq!(

Flow::Done

);

});

// Use the tag protocol trait.

// Expect the tag value to be walked.

walker.expect_walk().once().returning(|visitor| {

// Attempt to use the visitor.

assert!(visitor

.is_none());

Ok(())

assert!(matches!(

visitor

.visit(TagDyn(Symbol::new("test")), &mut walker)

VisitResult::Control(Flow::Done)

));

}

fn const_tag_can_be_visited() {

const TEST: u64 = Symbol::new("test").to_int();

// Expect a visit with the tag protocol.

mock.expect_visit().once().returning(|TagConst, walker| {

// Expect that the builder is attempted to be used by the walker for the value.

// Walk the value of the tag.

assert_eq!(

Flow::Done

);

});

// Use the tag protocol trait.

// Expect the tag value to be walked.

walker.expect_walk().once().returning(|visitor| {

// Attempt to use the visitor.

assert!(visitor

.is_none());

Ok(())

// Visit the tag protocol for kind test with the value walker.

assert!(matches!(

VisitResult::Control(Flow::Done)

));

}

#[test]

fn tag_proto() {

// The type id of the higher ranked type.

// The type id for the lifetime containing value protocol trait object.

}

};

use effectful::bound::Dynamic;

use effectful::SendSync;

use mockall::predicate::eq;

use treaty::{

any::{AnyTrait, BorrowedStatic, OwnedStatic, TempBorrowedMutStatic},

Flow,

};

mod common;

/// Tests support for custom type support in the value protocol.

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

struct MyValue;

// Expect the visit method to be called once with the custom type.

mock.expect_visit()

// Cast to a trait object for the value protocol.

// This shows the visit method is going through the trait.

// Visit the value.

let result = visitor.visit(OwnedStatic(MyValue)).into_value();

// The mock returns that it is done.

assert_eq!(result, VisitResult::Control(Flow::Done));

assert_eq!(

VisitResult::Control(Flow::Done)

);

}

// We borrow the context, this is what we pass to the visitor.

let value = &context;

// Expect the visit method to be called once with the borrowed value.

mock.expect_visit()

.return_const(VisitResult::Control(Flow::Done));

// Cast to a trait object for the value protocol.

// Visit the borrowed value.

assert_eq!(

Flow::Done.into()

);

assert_eq!(

VisitResult::Control(Flow::Done)

);

}

// We borrow the context, this is what we pass to the visitor.

let value = &mut context;

// Expect the visit method to be called once with the borrowed value.

mock.expect_visit()

// Cast to a trait object for the value protocol.

// We definitly need this for this test so the lifetime is invariant.

// Visit the context to show we can shorten the lifetime.

// This would also force the lifetime to be to long if this wasn't the Temp form.

/// Tests for the control flow returns the value protocol visit can return.

#[test]

fn all_visit_results() {

mock.expect_visit()

.once()

.with(eq(OwnedStatic(3)))

.return_const(VisitResult::Skipped(()));

// Visit can return a done.

assert_eq!(

#[test]

fn value_proto() {

// The type id of the higher ranked type.

// The type id for the lifetime containing value protocol trait object.

// They should be the same.

assert_eq!(id, name_id.into_type_id());

#[test]

fn as_hint() {

{

mock.expect_known().once().return_const(

(|_, _hint| {

Ok(ValueKnown {

preview: Some(Dynamic(&OwnedStatic(42))),

})

);

// The value protocol has no hint data, and it has no known data.

assert_eq!(

}

{

mock.expect_known().once().return_const(

(|_, _hint| {

Ok(ValueKnown {

preview: Some(Dynamic(&BorrowedStatic(&42))),

})

);

// The value protocol has no hint data, and it has no known data.

assert_eq!(

}

{

mock.expect_known().once().return_const(

(|_, _hint| Ok(ValueKnown { preview: None }))

);

// The value protocol has no hint data, and it has no known data.

assert_eq!(

use effectful::SendSync;

use treaty::protocol::walker::hint::{self, HintMeta};

mod common;

// /// This tests for the hint protocol being able to give the known info and being able to hint.

use effectful::{

SendSync,

};

use mockall::predicate::eq;

walk::walkers::core::r#struct::{StructTypeInfo, StructWalker},

DefaultMode, Flow, Walker,

};

use crate::common::{

builder::{EmptyError, MockBuilder},

protocol::{sequence::MockSequenceVisitor, tag::MockTagVisitor, value::MockValueVisitor},

};

mod common;

index: usize,

value: &'ctx Self::T,

mut visitor: DynVisitor<'a, 'ctx, E>,

E::future(unsafe {

ForceDynamic::new(async move {

match index {

let value = X { a: true, b: 42 };

// The struct walker using the info we provided about the struct.

// Expect a visit on the sequence protocol for the struct fields.

builder

.expect_traits_mut()

.once()

.returning(|_| {

// Expect the sequence visitor to be used.

visitor.expect_visit().once().returning(|scope| {

// Get the first field value.

{

// Expect a bool value for the field.

visitor

.expect_traits_mut()

.once()

.with(eq(TypeNameId::of::<

>()))

.returning(|_| {

let mut visitor =

// Expect true.

visitor

// Get the second field value.

{

// Expect a i32 value.

visitor

.expect_traits_mut()

.once()

.with(eq(TypeNameId::of::<

>()))

.returning(|_| {

// Expect a 42.

visitor

let value = X { a: true, b: 42 };

// The struct walker using the info we provided about the struct.

let mut seq = mockall::Sequence::new();

.once()

.in_sequence(&mut seq)

.with(eq(TypeNameId::of::<

Blocking,

>()))

.returning(|_| {