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

+ type Available

+ where

+ Self: Sized;

+

+ type Available = (

+ $($protocol,)*

+ );

+

+pub trait Build<'ctx, M, E: Effect>: Sized + Send + Sync {

+pub mod value;

+use crate::effect::Effect;

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

+macro_rules! value_builder {

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

+ $(impl<'ctx, M, E: Effect> crate::Build<'ctx, M, E> for $ty {

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

+ })*

+ };

+value_builder![u8, u16, u32, u64, u128, usize];

+value_builder![i8, i16, i32, i64, i128, isize];

+value_builder![f32, f64];

+value_builder![char];

+value_builder![bool];

+value_builder![()];

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

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

+ builders: Info::Builders,

+pub trait StructTypeInfo<'ctx, Mode: 'ctx, E: Effect>: 'static {

+ type Builders: Ss;

+ fn new_builders<'a>(seed: Self::Seed) -> ErasedEffective<'a, Self::Builders, E>;

+ fn from_builders<'a>(

+ builders: Self::Builders,

+ fn as_visitor<'a>(

+ builders: &'a mut Self::Builders,

+pub struct StructError<'ctx, Info, M, E: Effect>

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

+impl<'ctx, Info, Mode, E: Effect> StructError<'ctx, Info, Mode, E>

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

+impl<'ctx, Info, Mode, E: Effect> Debug for StructError<'ctx, Info, Mode, E>

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

+impl<'ctx, Info, Mode, E: Effect> Display for StructError<'ctx, Info, Mode, E>

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

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

+ type Error = StructError<'ctx, Info, Mode, E>;

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

+ Inner::Seed(seed) => Info::new_builders(seed).map(|builders| {

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

+ Info::new_builders(seed)

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

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

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

+ hint_protocol::<TagProto<tags::Struct, E>>(

+ hint_protocol::<TagProto<tags::Map, E>>(

+ hint_protocol::<SequenceProto<E>>(

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

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

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

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

+struct FieldVisitor<'a, 'ctx, I: StructTypeInfo<'ctx, M, E>, M, E: Effect> {

+ builders: &'a mut I::Builders,

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

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

+struct NameVisitor<'ctx, I: StructTypeInfo<'ctx, M, E>, M, E: Effect> {

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

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

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

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

+use core::fmt::Display;

+

+use crate::{

+ any::{

+ AnyTrait, BorrowedMutStatic, BorrowedMutStaticHrt, BorrowedStatic, BorrowedStaticHrt,

+ OwnedStatic, TempBorrowedMutStatic, TempBorrowedMutStaticHrt, TempBorrowedStatic,

+ TempBorrowedStaticHrt,

+ },

+ any_trait,

+ effect::{Effect, EffectExt as _, Effective as _, EffectiveExt as _, ErasedEffective, Ss},

+ hkt::Marker,

+ protocol::{

+ visitor::{

+ EffectiveVisitExt as _, RequestHint, RequestHintProto, Value, ValueProto, VisitResult,

+ },

+ walker::hint::hint_protocol,

+ DynVisitor, DynWalker,

+ },

+ Flow,

+};

+

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

+ }

+}

+

+impl<T> Display 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>())

+ }

+}

+

+pub enum Cloneable {}

+pub enum NotCloneable {}

+

+/// Builder for `'static` values.

+///

+/// This builder only uses the [`Value`] protocol.

+pub struct ValueBuilder<T, Clone, E> {

+ value: Option<T>,

+ _marker: Marker<(E, Clone)>,

+}

+

+impl<T: Ss, Clone, E> crate::BuilderTypes for ValueBuilder<T, Clone, E> {

+ type Error = ValueError<T>;

+

+ type Value = T;

+

+ type Seed = ();

+}

+

+impl<'ctx, T: Ss + 'static, Clone, E: Effect> crate::Builder<'ctx, E> for ValueBuilder<T, Clone, E>

+where

+ Self: AnyTrait<'ctx>,

+{

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

+ where

+ Self: 'a,

+ {

+ E::ready(self.value.ok_or(ValueError(Default::default())))

+ }

+

+ fn from_seed<'a>(_seed: Self::Seed) -> ErasedEffective<'a, Self, E>

+ where

+ Self: 'a,

+ {

+ E::ready(Self {

+ value: None,

+ _marker: Default::default(),

+ })

+ }

+

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

+ DynVisitor(self)

+ }

+}

+

+any_trait! {

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

+ RequestHintProto<E>,

+ ValueProto<OwnedStatic<T>, E>,

+ ] where

+ E: Effect,

+ T: Ss + 'static

+}

+

+any_trait! {

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

+ RequestHintProto<E>,

+ ValueProto<OwnedStatic<T>, E>,

+ ValueProto<BorrowedStaticHrt<T>, E>,

+ ValueProto<TempBorrowedStaticHrt<T>, E>,

+ ValueProto<BorrowedMutStaticHrt<T>, E>,

+ ValueProto<TempBorrowedMutStaticHrt<T>, E>,

+ ] where

+ E: Effect,

+ T: Ss + 'static + Clone,

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> RequestHint<'ctx, E> for ValueBuilder<T, NotCloneable, E> {

+ fn request_hint<'a>(

+ &'a mut self,

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

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

+ E::as_ctx((self, walker), |(this, walker)| {

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

+ })

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

+ }

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> RequestHint<'ctx, E> for ValueBuilder<T, Cloneable, E>

+where

+ T: Clone,

+{

+ fn request_hint<'a>(

+ &'a mut self,

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

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

+ E::as_ctx((self, walker), |(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()

+ })

+ .if_not_finished(|(this, walker)| {

+ hint_protocol::<ValueProto<TempBorrowedStaticHrt<T>, E>>(walker.cast(), *this, ())

+ .cast()

+ })

+ .if_not_finished(|(this, walker)| {

+ hint_protocol::<ValueProto<BorrowedMutStaticHrt<T>, E>>(walker.cast(), *this, ()).cast()

+ })

+ .if_not_finished(|(this, walker)| {

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

+ .cast()

+ })

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

+ }

+}

+

+impl<'ctx, T: Ss + 'static, Clone, E: Effect> Value<'ctx, OwnedStatic<T>, E>

+ for ValueBuilder<T, Clone, E>

+{

+ fn visit<'a>(

+ &'a mut self,

+ OwnedStatic(value): OwnedStatic<T>,

+ ) -> ErasedEffective<'a, VisitResult<OwnedStatic<T>>, E>

+ where

+ 'ctx: 'a,

+ {

+ self.value = Some(value);

+

+ E::ready(Flow::Done.into())

+ }

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> Value<'ctx, BorrowedStaticHrt<T>, E>

+ for ValueBuilder<T, Cloneable, E>

+where

+ T: Clone,

+{

+ fn visit<'a>(

+ &'a mut self,

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

+ ) -> ErasedEffective<'a, VisitResult<BorrowedStatic<'ctx, T>>, E>

+ where

+ 'ctx: 'a,

+ {

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

+

+ E::ready(Flow::Done.into())

+ }

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> Value<'ctx, TempBorrowedStaticHrt<T>, E>

+ for ValueBuilder<T, Cloneable, E>

+where

+ T: Clone,

+{

+ fn visit<'a>(

+ &'a mut self,

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

+ ) -> ErasedEffective<'a, VisitResult<TempBorrowedStatic<'a, T>>, E>

+ where

+ 'ctx: 'a,

+ {

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

+

+ E::ready(Flow::Done.into())

+ }

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> Value<'ctx, BorrowedMutStaticHrt<T>, E>

+ for ValueBuilder<T, Cloneable, E>

+where

+ T: Clone,

+{

+ fn visit<'a>(

+ &'a mut self,

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

+ ) -> ErasedEffective<'a, VisitResult<BorrowedMutStatic<'ctx, T>>, E>

+ where

+ 'ctx: 'a,

+ {

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

+

+ E::ready(Flow::Done.into())

+ }

+}

+

+impl<'ctx, T: Ss + 'static, E: Effect> Value<'ctx, TempBorrowedMutStaticHrt<T>, E>

+ for ValueBuilder<T, Cloneable, E>

+where

+ T: Clone,

+{

+ fn visit<'a>(

+ &'a mut self,

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

+ ) -> ErasedEffective<'a, VisitResult<TempBorrowedMutStatic<'a, T>>, E>

+ where

+ 'ctx: 'a,

+ {

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

+

+ E::ready(Flow::Done.into())

+ }

+}

+#[must_use]

+#[must_use]

+#[must_use]

+ fn into_walker<'e>(self) -> $crate::effect::ErasedEffective<'e, Self::Walker, E> {

+ E::ready($crate::walkers::core::r#struct::StructWalker::new(self))

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

+ .then(|value_walker| {

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

+ $crate::Walker::<'ctx, E>::walk(walker, visitor)

+ })

+ .map(|result| match result {

+ Y::build(x.as_walker()).unwrap()

+ // x.walk(Y::new_builder()).unwrap()

+ use crate::effect::blocking::BlockOn as _;

+

+

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

+ let x = X { a: false, b: true };

+

+ let y = Y::build_async(x.as_async_walker().await).await.unwrap();

+

+ assert_eq!(y, Y { a: false, b: true });

+ });

+

+ let x = X { a: false, b: true };

+

+ let y = Y::build(x.as_walker()).unwrap();

+

+ assert_eq!(y, Y { a: false, b: true });

+ $vis struct Builders<'ctx, M: 'ctx, E: $crate::effect::Effect> {

+ $vis enum Error<'ctx, M: 'ctx, E: $crate::effect::Effect> {

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

+ impl<'ctx, M: 'ctx, E: $crate::effect::Effect> ::core::fmt::Debug for Error<'ctx, M, E> {

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

+ f.write_str(match self {

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

+ })

+ }

+ }

+

+ impl<'ctx, M: 'ctx, E: $crate::effect::Effect> ::core::fmt::Display for Error<'ctx, M, E> {

+ impl<'ctx, M: 'ctx, E: $crate::effect::Effect> $crate::builders::core::r#struct::StructTypeInfo<'ctx, M, E> for __Info {

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

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

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

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

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

+ fn as_visitor<'a>(

+ builders: &'a mut Self::Builders,

+

+ pub fn map_skipped<R, F>(self, f: F) -> VisitResult<R>

+ where

+ F: FnOnce(S) -> R,

+ {

+ match self {

+ VisitResult::Skipped(s) => VisitResult::Skipped(f(s)),

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

+ }

+ }

+pub fn request_hint<'a, 'ctx, E: Effect>(

+ pub type FieldNames = TagConst<{ Symbol::new("Field Names").to_int() }>;

+ pub type TypeName = TagConst<{ Symbol::new("Type Name").to_int() }>;

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

+ any::TypeName,

+ effect::{Effect, EffectiveExt as _, ErasedEffective, ReadyExt as _},

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

+pub trait HintMeta: TypeName::MemberType + Send + Sync + 'static {

+ visitor: &'visitor mut TypeName::T<'visitor, 'ctx, Protocol>,

+ visitor: &'visitor mut TypeName::T<'visitor, 'ctx, Protocol>,

+ object.hint(visitor, hint).map(Into::into)

+use futures::Future;

+

+ effect::{

+ blocking::Blocking, r#async::Async, Effect, Effective, EffectiveExt, ErasedEffective,

+ },

+ fn build_async<'ctx, W>(

+ walker: W,

+ ) -> impl Future<Output = Result<Self, BuildError<Self::Builder, W>>> + Send + Sync

+ where

+ Self: Build<'ctx, DefaultMode, Async>,

+ <Self::Builder as BuilderTypes>::Seed: Default,

+ W: Walker<'ctx, Async>,

+ {

+ async {

+ match transform::<Self::Builder, _, _>(Default::default(), walker)

+ .into_future()

+ .await

+ {

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

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

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

+ }

+ }

+ }

+

+ fn as_walker<'ctx: 'a, 'a>(&'a self) -> <&'a Self as Walk<'ctx, DefaultMode, Blocking>>::Walker

+ where

+ &'a Self: Walk<'ctx, DefaultMode, Blocking>,

+ {

+ Walk::into_walker(self).value()

+ }

+

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

+ ) -> impl Future<Output = <&'a Self as Walk<'ctx, DefaultMode, Async>>::Walker> + Send + Sync

+ &'a Self: Walk<'ctx, DefaultMode, Async>,

+ Walk::into_walker(self).into_future()

+ let _ = Walk::into_walker(self).value().walk(builder.as_visitor());

+ fn into_walker<'e>(self) -> ErasedEffective<'e, Self::Walker, E>

+ where

+ Self: 'e;

+use crate::{

+ effect::{Effect, ErasedEffective},

+ Walk, WalkerTypes,

+};

+ fn into_walker<'e>(self) -> ErasedEffective<'e, Self::Walker, E> {

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

+ fn into_walker<'e>(self) -> ErasedEffective<'e, Self::Walker, E> {

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

+ request_hint, tags, visit_sequence, visit_tag, visit_value, EffectiveVisitExt as _,

+ Recoverable, RecoverableKnown, RecoverableProto, RecoverableScope, Sequence,

+ SequenceKnown, SequenceProto, SequenceScope, Tag, TagConst, TagDyn, TagError, TagKnown,

+ TagProto, Value, ValueKnown, ValueProto, VisitResult,

+ DynWalkerAdapter, Flow, Status, WalkerTypes, TAG_FIELD_NAMES, TAG_MAP, TAG_STRUCT, TAG_TYPE_ID,

+ TAG_TYPE_NAME,

+ _visitor: &'visitor mut (dyn Recoverable<'ctx, E> + Send + Sync),

+ _visitor: &'visitor mut (dyn Tag<'ctx, tags::FieldNames, E> + Send + Sync),

+ _visitor: &'visitor mut (dyn Tag<'ctx, tags::TypeName, E> + Send + Sync),

+ _visitor: &'visitor mut (dyn Tag<'ctx, tags::Map, E> + Send + Sync),

+ visitor: &'visitor mut (dyn Tag<'ctx, tags::Struct, E> + Send + Sync),

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

+ |(visitor, noop_walker)| {

+ visitor

+ .visit(TagConst, noop_walker)

+ .map(|status| status.to_flow().unwrap_or(Flow::Continue))

+ .cast()

+ _visitor: &'visitor mut (dyn Tag<'ctx, tags::TypeId, E> + Send + Sync),

+ _visitor: &'visitor mut (dyn Tag<'ctx, TagDyn, E> + Send + Sync),

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

+ todo!()

+ // match hint.kind.0 {

+ // crate::TAG_TYPE_ID => {

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

+ // self,

+ // visitor,

+ // TagHint { kind: TagConst },

+ // )

+ // }

+ // crate::TAG_STRUCT => {

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

+ // self,

+ // visitor,

+ // TagHint { kind: TagConst },

+ // )

+ // }

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

+ // self,

+ // visitor,

+ // TagHint { kind: TagConst },

+ // ),

+ // crate::TAG_TYPE_NAME => {

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

+ // self,

+ // visitor,

+ // TagHint { kind: TagConst },

+ // )

+ // }

+ // crate::TAG_FIELD_NAMES => Hint::<

+ // 'ctx,

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

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

+ // _ => E::ready(Flow::Continue),

+ // }

+ _visitor: &'visitor mut (dyn Value<'ctx, BorrowedStaticHrt<I::T>, E> + Send + Sync),

+ visitor: &'visitor mut (dyn Sequence<'ctx, E> + Send + Sync),

+ visitor

+ .visit(*this)

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

+mod common;

+

+use treaty::{

+ any::OwnedStatic,

+ effect::blocking::Blocking,

+ protocol::{

+ visitor::{request_hint, ValueProto},

+ DynWalker,

+ },

+ BuildExt as _, Builder as _, Flow,

+};

+

+use crate::common::protocol::hint::MockHintWalker;

+

+#[test]

+fn value_builder_gives_value_protocol_as_hint() {

+ // Create a builder for a i32.

+ let mut builder = i32::new_builder();

+

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

+ let mut walker = MockHintWalker::<ValueProto<OwnedStatic<i32>, Blocking>>::new();

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

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

+ assert_eq!(visitor.visit(OwnedStatic(42)).value(), Flow::Done.into());

+

+ // We are done as the walker.

+ Flow::Done

+ });

+

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

+ assert_eq!(

+ request_hint::<Blocking>(builder.as_visitor(), DynWalker(&mut walker)).value(),

+ Flow::Done.into()

+ );

+

+ // The builder should have the value.

+ assert_eq!(builder.build().value().unwrap(), 42);

+}

+

+ type Available = () where Self: Sized;

+ pub fn hint<'a, 'b, 'c, 'ctx>(&'a mut self, visitor: &'b mut TypeName::T<'b, 'ctx, P>, hint: MetaHint<'c, 'ctx, P>) -> Flow;

+ visitor: &'visitor mut TypeName::T<'visitor, 'ctx, P>,

+

+

+ type Available = () where Self: Sized;

+ any::{TypeName, TypeNameId},

+ impl<'a, 'ctx> TypeName::MemberTypeForLt<'a, 'ctx, &'a &'ctx ()> for MyProtocol {

+ type T = MyProtocol;

+ }

+

+ impl<'a, 'ctx> TypeName::LowerTypeWithBound<'a, 'ctx, &'a &'ctx ()> for MyProtocol {

+ type Higher = MyProtocol;

+ }

+