+impl<'lt> dyn AnyTrait<'lt> + Send + '_ {

+ let y: &(dyn AnyTrait<'_> + Send) = &x;

+ effect::{Effect, Future},

+pub trait Build<'ctx>: BuilderTypes<'ctx, Value = Self> + Send {

+ type Builder<E: Effect<'ctx>>: Builder<'ctx, Seed = Self::Seed, Error = Self::Error, Value = Self, Effect = E>;

+}

+

+pub trait BuilderTypes<'ctx> {

+ type Seed: Send;

+

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

+ type Error: Send;

+

+ /// Type to be built.

+ type Value: Send;

+pub trait Builder<'ctx>: BuilderTypes<'ctx> + Sized + Send {

+ type Effect: Effect<'ctx>;

+ fn from_seed<'a>(seed: Self::Seed) -> Future<'a, 'ctx, Self, Self::Effect>

+ where

+ Self: 'a;

+ fn build<'a>(self) -> Future<'a, 'ctx, Result<Self::Value, Self::Error>, Self::Effect>

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

+// #[cfg(feature = "serde")]

+// pub mod serde;

+// pub mod array;

+

+ effect::{Effect, Future},

+ protocol::{visitor::value::Value, Visitor},

+impl<'ctx> crate::Build<'ctx> for bool {

+ type Builder<E: Effect<'ctx>> = Builder<E>;

+impl<'ctx> crate::BuilderTypes<'ctx> for bool {

+ type Seed = ();

+

+}

+

+impl<'ctx, E: Effect<'ctx>> crate::BuilderTypes<'ctx> for Builder<E> {

+ type Error = Error;

+

+ type Value = bool;

+

+ type Seed = ();

+}

+

+impl<'ctx, E: Effect<'ctx>> crate::Builder<'ctx> for Builder<E> {

+ type Effect = E;

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

+ E::wrap(core::future::ready(self.0.ok_or(Error::Incomplete)))

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

+ where

+ Self: 'a,

+ {

+ E::wrap(core::future::ready(Self(None, PhantomData)))

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

+ dyn Value<'a, 'ctx, OwnedStatic<bool>, E> + 'a,

+ ] where E: Effect<'ctx>

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<bool>, E> for Builder<E> {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(ControlFlow::Continue(())))

+ effect::{Effect, Future},

+ protocol::visitor::{

+ tagged::{Tagged, TaggedScope},

+ value::Value,

+ },

+impl<'ctx, T> crate::Build<'ctx> for Option<T>

+ T: crate::Build<'ctx>,

+ <T as crate::BuilderTypes<'ctx>>::Seed: Default,

+ type Builder<E: Effect<'ctx>> = Builder<'ctx, T::Builder<E>, E>;

+impl<'ctx, T> crate::BuilderTypes<'ctx> for Option<T>

+where

+ T: crate::Build<'ctx>,

+ <T as crate::BuilderTypes<'ctx>>::Seed: Default,

+{

+ type Error = Error<'ctx, T::Error>;

+

+ type Value = Option<T::Value>;

+

+ type Seed = IgnoreMissing;

+}

+

+pub struct Builder<'ctx, B: crate::Builder<'ctx>, E> {

+ _marker: PhantomData<fn() -> E>,

+impl<'ctx, B, E: Effect<'ctx>> crate::BuilderTypes<'ctx> for Builder<'ctx, B, E>

+ B: crate::Builder<'ctx, Effect = E>,

+ <B as crate::BuilderTypes<'ctx>>::Seed: Default,

+ type Seed = IgnoreMissing;

+}

+

+impl<'ctx, B, E: Effect<'ctx>> crate::Builder<'ctx> for Builder<'ctx, B, E>

+where

+ B: crate::Builder<'ctx, Effect = E>,

+ <B as crate::BuilderTypes<'ctx>>::Seed: Default,

+{

+ type Effect = E;

+

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

+ E::wrap(core::future::ready(match self.value {

+ }))

+ fn from_seed<'a>(seed: Self::Seed) -> Future<'a, 'ctx, Self, E> {

+ E::wrap(core::future::ready(Self {

+ }))

+ fn as_visitor(&mut self) -> crate::protocol::Visitor<'_, 'ctx> {

+ impl['a, 'ctx, B, E] Builder<'ctx, B, E> = [

+ dyn Tagged<'ctx, E> + 'a,

+ ] where B: crate::Builder<'ctx, Effect = E>, E: Effect<'ctx>,

+ <B as crate::BuilderTypes<'ctx>>::Seed: Default,

+impl<'ctx, B, E: Effect<'ctx>> Tagged<'ctx, E> for Builder<'ctx, B, E>

+ B: crate::Builder<'ctx, Effect = E>,

+ <B as crate::BuilderTypes<'ctx>>::Seed: Default,

+ scope: &'a mut (dyn TaggedScope<'ctx, E> + Send),

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(async {

+ match scope.kind().await {

+ symbol::KEY | symbol::VARIANT => {

+ // This tag is the variant name/number.

+ let mut variant = VariantVisitor::<'ctx, B::Error, E> {

+ value: None,

+ _marker: PhantomData,

+ };

+ scope.tag(&mut variant).await?;

+ let variant = match variant.value {

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

+ Some(Err(error)) => {

+ self.value = Some(Err(error));

+ return ControlFlow::Break(());

+ }

+ None => {

+ self.value = Some(Err(Error::NoVariantGiven));

+ return ControlFlow::Break(());

+ }

+ };

+ match variant {

+ Variant::None => {

+ // Nothing more needs to be done.

+ self.value = Some(Ok(None));

+ ControlFlow::Continue(())

+ }

+ Variant::Some => {

+ // Now build a T.

+ let mut builder = B::from_seed(Default::default()).await;

+ scope.value(builder.as_visitor()).await?;

+ match builder.build().await {

+ Ok(value) => {

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

+ ControlFlow::Continue(())

+ }

+ Err(error) => {

+ self.value = Some(Err(Error::VariantSome(error)));

+ ControlFlow::Break(())

+ }

+ _ => {

+ // Ignore any other tags and just use the value.

+ scope.value(self).await

+ }

+ })

+pub struct VariantVisitor<'ctx, T, E> {

+ _marker: PhantomData<fn() -> E>,

+ impl['a, 'ctx, T, E] VariantVisitor<'ctx, T, E> = [

+ dyn Value<'a, 'ctx, TempBorrowedStatic<'a, str>, E> + 'a,

+ dyn Value<'a, 'ctx, BorrowedStatic<'ctx, str>, E> + 'a,

+ dyn Value<'a, 'ctx, OwnedStatic<&'static str>, E> + 'a,

+ dyn Value<'a, 'ctx, OwnedStatic<u8>, E> + 'a,

+ dyn Value<'a, 'ctx, OwnedStatic<u16>, E> + 'a,

+ ] where E: Effect<'ctx>

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> Value<'a, 'ctx, TempBorrowedStatic<'a, str>, E>

+ for VariantVisitor<'ctx, T, E>

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(

+ }))

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> Value<'a, 'ctx, BorrowedStatic<'ctx, str>, E>

+ for VariantVisitor<'ctx, T, E>

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(

+ }))

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<&'static str>, E>

+ for VariantVisitor<'ctx, T, E>

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(

+ }))

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<u8>, E>

+ for VariantVisitor<'ctx, T, E>

+{

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(

+ }))

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<u16>, E>

+ for VariantVisitor<'ctx, T, E>

+{

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(core::future::ready(

+ }))

+use core::{

+ marker::PhantomData,

+ pin::pin,

+ ptr,

+ task::{Context, Poll, RawWaker, RawWakerVTable, Waker},

+};

+

+use crate::{higher_ranked_trait, higher_ranked_type};

+

+higher_ranked_trait! {

+ pub type class SendFuture['ctx, Output]: [for<'lt> core::future::Future<Output = Output> + Send + 'lt]

+ where {

+ Output: Send,

+ for where {

+ Output: 'lt,

+/// Trait for effects.

+pub trait Effect<'ctx>: 'static {

+ type Future<T: Send>: SendFuture::Trait<'ctx, T>;

+

+ fn wrap<'a, F>(future: F) -> SendFuture::T<'a, 'ctx, Self::Future<F::Output>, F::Output>

+ where

+ F: core::future::Future + Send + 'a,

+ <F as core::future::Future>::Output: Send;

+

+ #[cfg(feature = "alloc")]

+ #[inline]

+ fn wrap_boxed<'a, F>(

+ future: core::pin::Pin<Box<F>>,

+ ) -> SendFuture::T<'a, 'ctx, Self::Future<F::Output>, F::Output>

+ where

+ F: core::future::Future + Send + 'a,

+ <F as core::future::Future>::Output: Send,

+ {

+ Self::wrap(future)

+pub type Future<'a, 'ctx, T, E> = SendFuture::T<'a, 'ctx, <E as Effect<'ctx>>::Future<T>, T>;

+pub struct Blocking<B = Spin> {

+ _marker: PhantomData<fn() -> B>,

+pub trait BlockOn: 'static {

+ fn block_on<F>(future: F) -> F::Output

+ where

+ F: core::future::Future + Send,

+ <F as core::future::Future>::Output: Send;

+/// [`BlockOn`] implementer that just spins on the future.

+///

+/// This is useful for futures that are alwayd ready.

+pub enum Spin {}

+

+impl BlockOn for Spin {

+ #[inline(always)]

+ fn block_on<F>(future: F) -> F::Output

+ where

+ F: core::future::Future + Send,

+ {

+ let waker = noop();

+ let mut context = Context::from_waker(&waker);

+

+ let mut future = pin!(future);

+ loop {

+ if let Poll::Ready(value) = future.as_mut().poll(&mut context) {

+ return value;

+ }

+ }

+ }

+#[inline]

+pub fn noop() -> Waker {

+ const VTABLE: &'static RawWakerVTable = &RawWakerVTable::new(

+ // Cloning just returns a new no-op raw waker

+ |_| RAW,

+ // `wake` does nothing

+ |_| {},

+ // `wake_by_ref` does nothing

+ |_| {},

+ // Dropping does nothing as we don't allocate anything

+ |_| {},

+ );

+ const RAW: RawWaker = RawWaker::new(ptr::null(), &VTABLE);

+ unsafe { Waker::from_raw(RAW) }

+higher_ranked_type! {

+ pub type ReadyFuture['ctx, Output]: (SendFuture)[Output]

+ where {

+ Output: Send,

+ } = for<'lt> core::future::Ready<Output>

+}

+impl<'ctx, B: BlockOn> Effect<'ctx> for Blocking<B> {

+ type Future<T: Send> = ReadyFuture<'ctx, T>;

+ fn wrap<'a, F>(future: F) -> SendFuture::T<'a, 'ctx, Self::Future<F::Output>, F::Output>

+ where

+ F: core::future::Future + Send + 'a,

+ <F as core::future::Future>::Output: Send,

+ {

+ core::future::ready(B::block_on(future))

+ }

+higher_ranked_type! {

+ pub type BoxFuture['ctx, Output]: (SendFuture)[Output]

+ where {

+ Output: Send,

+ } = for<'lt> core::pin::Pin<Box<dyn core::future::Future<Output = Output> + Send + 'lt>>

+pub enum Async {}

+impl<'ctx> Effect<'ctx> for Async {

+ type Future<T: Send> = BoxFuture<'ctx, T>;

+

+ fn wrap<'a, F>(future: F) -> SendFuture::T<'a, 'ctx, Self::Future<F::Output>, F::Output>

+ where

+ F: core::future::Future + Send + 'a,

+ <F as core::future::Future>::Output: Send,

+ {

+ Box::pin(future)

+ }

+ fn wrap_boxed<'a, F>(

+ future: core::pin::Pin<Box<F>>,

+ ) -> SendFuture::T<'a, 'ctx, Self::Future<F::Output>, F::Output>

+ where

+ F: core::future::Future + Send + 'a,

+ <F as core::future::Future>::Output: Send,

+ {

+ future

+ }

+//! Higher-ranked traits and types.

+//!

+//! A higher-ranked type is a type that needs a lifetime to be "complete". Consider the following

+//! code.

+//! ```rs

+//! type IntBorrow<'a> = &'a i32;

+//! ```

+//! What if we could pass just `IntBorrow` around as a type; without it's lifetime.

+//! In Rust syntax, this type would be `for<'a> IntBorrow<'a>`. `'a` can be filled in with any

+//! lifetime. Sadly, Rust only allows `for<'a>` in trait objects. However, trait object provide

+//! enough for us to implement arbitrary hifher-ranked types with some extra effort.

+//!

+//! In this module the [`higher_ranked_type!`] macro generates a type that needs a lifetime to

+//! be complete. Before a higher-ranked type can be generated we need a higher-ranked trait to

+//! describe what behavior the resulting "true" type will have.

+//!

+//! The [`higher_ranked_trait!`] macro cgenerates a trait that can be used with

+//! [`higher_ranked_type!`] and as a bound by code wanting to accept a higher ranked type.

+//! Bounding a generic by a higher-ranked trait simultaniously allows any higher-ranked type with

+//! a "true" type with the required traits and any lifetime to be given to that "true" type.

+

+/// Used to cause `'lt` to have extra bounds when using `for<'lt>` syntax.

+///

+/// Including this type where a `for<'lt>` is being generated will result in the following bounds

+/// being applied.

+/// * `'bound: 'lt` - `'lt` will **not** outlive `'bound`.

+/// * `T: 'lt` - `T` will outlive `'lt`.

+pub type Bound<'lt, 'bound, T = ()> = (&'lt &'bound (), &'lt T);

+

+/// Generate a higher-ranked trait.

+macro_rules! higher_ranked_trait {

+ {

+ $vis:vis type class $name:ident[$ctx:lifetime $(, $($generic:tt)*)?]: [for<$lt:lifetime> $($($provides:tt)+)?]

+ $(where {

+ $($bound:tt)*

+ })?

+ $(for where {

+ $($for_bound:tt)*

+ })?

+ } => {

+ #![allow(unused, non_snake_case)]

+

+ pub trait ForLt<$lt, $ctx: $lt, B $(, $($generic)*)?>

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

+

+ {

+ type T$(: $($provides)+)?;

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

+ where

+ $($($bound)*)?

+ {}

+ impl<$ctx, ____ $(, $($generic)*)?> Trait<$ctx $(, $($generic)*)?> for ____

+ ____: for<$lt> ForLt<$lt, $ctx, $crate::hkt::Bound<$lt, $ctx $(, $($generic)*)?> $(, $($generic)*)?>,

+ $($($bound)*)?

+ pub type T<$lt, $ctx, H $(, $($generic)*)?> = <H as ForLt<$lt, $ctx, $crate::hkt::Bound<$lt, $ctx $(, $($generic)*)?> $(, $($generic)*)?>>::T;

+pub use higher_ranked_trait;

+/// Generate a higher-ranked type.

+macro_rules! higher_ranked_type {

+ {

+ $vis:vis type $name:ident[$ctx:lifetime $(, $($generic:tt)*)?]: ($($type_class:tt)*)$([$($type_class_generic:tt)*])?

+ $(where {$($bound:tt)*})?

+ = for<$lt:lifetime> $for_lt_type:ty

+ $(where {$($higher_bound:tt)*})?

+ } => {

+ impl<$lt, $ctx $(, $($generic)*)?> $($type_class)*::ForLt<$lt, $ctx, $crate::hkt::Bound<$lt, $ctx $(, $($generic)*)?> $(, $($type_class_generic)*)?> for $name<$ctx $(, $($generic)*)?>

+ where $($($bound)*)? $($($higher_bound)*)?

+ type T = $for_lt_type;

+pub use higher_ranked_type;

+

+higher_ranked_trait! {

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

+}

+ /// Some trait with two lifetimes and a generic.

+ trait Demo<'lt, 'ctx, T: Send + 'lt> {

+ impl<'lt, 'ctx, T: Send + 'lt> Demo<'lt, 'ctx, T> for i32 {

+ impl<'lt, 'ctx, T: Send + 'lt> Demo<'lt, 'ctx, T> for &'lt (dyn Demo<'lt, 'ctx, T> + 'lt) {

+ // Higher-ranked trait that requires the "true" type to implement Demo.

+ higher_ranked_trait! {

+ type class Any['ctx, T]: [for<'lt> Demo<'lt, 'ctx, T>]

+ where {

+ T: Send,

+ }

+ for where {

+ T: 'lt

+ }

+ }

+ // Higher-ranked type with a "true" type of a borrow of a trait object.

+ // The complex part to support here is the `+ 'lt`.

+ // This entire module is specialized to support this usecase because that is what treaty needs

+ // for it's API.

+ higher_ranked_type! {

+ type X['ctx, T]: (Any)[T]

+ where {

+ T: Send,

+ } = for<'lt> &'lt (dyn Demo<'lt, 'ctx, T> + 'lt)

+ }

+ // We bound the generic T by the higher-ranked trait Any.

+ //

+ // We then inject a 'lt into the higher-ranked type to get a "true" type.

+ fn demo<'lt, 'ctx, T: Any::Trait<'ctx, i32>>(x: Any::T<'lt, 'ctx, T, i32>, y: &'lt &'ctx i32) {

+ // The lifetimes here can't be 'static because local isn't static even though z could be.

+ let z: &dyn Demo<'_, '_, i32> = &8i32;

+ demo::<X<'_, i32>>(z, local);

+mod transform;

+pub use transform::*;

+use crate::any::AnyTrait;

+pub type Visitor<'a, 'ctx> = &'a mut (dyn AnyTrait<'ctx> + Send + 'a);

+pub type Walker<'a, 'ctx> = &'a mut (dyn AnyTrait<'ctx> + Send + 'a);

+pub mod request_hint;

+pub mod sequence;

+pub mod tagged;

+pub mod value;

+ effect::{Effect, Future},

+pub trait RequestHint<'a, 'ctx: 'a, E: Effect<'ctx>> {

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

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ E: Effect<'ctx>,

+ effect::{Effect, Future},

+ higher_ranked_type,

+ hkt::AnySend,

+ protocol::{walker::hint::HintMeta, Visitor},

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

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ E: Effect<'ctx>,

+ E: Effect<'ctx>,

+ E: Effect<'ctx>,

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), Status>, E>;

+higher_ranked_type! {

+ pub type KnownHkt['ctx]: (AnySend) = for<'lt> Known

+}

+impl<'a, 'ctx: 'a, E: Effect<'ctx>> HintMeta<'ctx> for dyn Sequence<'ctx, E> + '_ {

+ effect::{Effect, Future},

+ higher_ranked_type,

+ hkt::AnySend,

+ protocol::{walker::hint::HintMeta, Visitor},

+pub trait Tagged<'ctx, E: Effect<'ctx>> {

+ scope: &'a mut (dyn TaggedScope<'ctx, E> + Send),

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ E: Effect<'ctx>,

+ E: Effect<'ctx>,

+pub trait TaggedScope<'ctx, E: Effect<'ctx>> {

+ fn kind<'a>(&mut self) -> Future<'a, 'ctx, Symbol, E>;

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+higher_ranked_type! {

+ pub type KnownHkt['ctx]: (AnySend) = for<'lt> Known

+}

+ effect::{Effect, Future},

+ higher_ranked_type,

+ hkt::AnySend,

+ protocol::walker::hint::HintMeta,

+pub trait Value<'a, 'ctx: 'a, T, E: Effect<'ctx>> {

+ fn visit(&'a mut self, value: T) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ E: Effect<'ctx>,

+ E: Effect<'ctx>,

+higher_ranked_type! {

+ pub type Known['ctx]: (AnySend) = for<'lt> ()

+}

+impl<'a, 'ctx: 'a, T, E: Effect<'ctx>> HintMeta<'ctx> for dyn Value<'a, 'ctx, T, E> + 'a {

+ type Known = Known<'ctx>;

+ use core::{marker::PhantomData, ops::ControlFlow};

+ effect::{BlockOn, Blocking, Spin},

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

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, OwnedStatic<i32>, E> for Visitor<E>

+ where

+ E: Effect<'ctx>,

+ {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(async move {

+ self.0 = Some(value);

+ ControlFlow::Continue(())

+ })

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedStatic<'ctx, i32>, E> for Visitor<E>

+ where

+ E: Effect<'ctx>,

+ {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(async {

+ self.0 = Some(*value);

+ ControlFlow::Continue(())

+ })

+ impl['a, 'ctx, E] Visitor<E> = [

+ dyn Value<'a, 'ctx, OwnedStatic<i32>, E> + 'a,

+ dyn Value<'a, 'ctx, BorrowedStatic<'ctx, i32>, E> + 'a,

+ ] where E: Effect<'ctx>,

+ let mut v = Visitor::<Blocking>(None, PhantomData);

+ let object: &mut (dyn AnyTrait<'_> + Send) = &mut v;

+ Spin::block_on(

+ object

+ .upcast_mut::<dyn Value<'_, '_, OwnedStatic<i32>, Blocking>>()

+ .unwrap()

+ .visit(OwnedStatic(42)),

+ );

+ let object: &mut (dyn AnyTrait<'_> + Send) = &mut v;

+ Spin::block_on(

+ object

+ .upcast_mut::<dyn Value<'_, '_, BorrowedStatic<'_, i32>, Blocking>>()

+ .unwrap()

+ .visit(BorrowedStatic(&101)),

+ );

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

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedMutStatic<'ctx, String>, E> for Visitor<'ctx, E>

+ where

+ E: Effect<'ctx>,

+ {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(async {

+ self.0 = Some(value);

+

+ ControlFlow::Continue(())

+ })

+ impl['a, 'ctx, E] Visitor<'ctx, E> = [

+ dyn Value<'a, 'ctx, BorrowedMutStatic<'ctx, String>, E> + 'a,

+ ] where E: Effect<'ctx>

+ let mut v = Visitor::<Blocking>(None, PhantomData);

+ let object: &mut (dyn AnyTrait<'_> + Send) = &mut v;

+ Spin::block_on(

+ object

+ .upcast_mut::<dyn Value<'_, '_, _, Blocking>>()

+ .unwrap()

+ .visit(BorrowedMutStatic(&mut y)),

+ );

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

+ impl<'a, 'ctx: 'a, E> Value<'a, 'ctx, BorrowedStatic<'ctx, str>, E> for Visitor<'ctx, E>

+ where

+ E: Effect<'ctx>,

+ {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ E::wrap(async {

+ self.0 = Some(value);

+ ControlFlow::Continue(())

+ })

+ impl['a, 'ctx, E] Visitor<'ctx, E> = [

+ dyn Value<'a, 'ctx, BorrowedStatic<'ctx, str>, E> + 'a,

+ ] where E: Effect<'ctx>

+ let mut v = Visitor::<Blocking>(None, PhantomData);

+ let object: &mut (dyn AnyTrait<'_> + Send) = &mut v;

+ Spin::block_on(

+ object

+ .upcast_mut::<dyn Value<'_, '_, BorrowedStatic<'_, str>, Blocking> + '_>()

+ .unwrap()

+ .visit(BorrowedStatic(&y)),

+ );

+pub mod hint;

+ effect::{Effect, Future},

+ hkt::AnySend,

+ type Known: AnySend::Trait<'ctx>;

+pub type Known<'a, 'ctx, Protocol> = AnySend::T<'a, 'ctx, <Protocol as HintMeta<'ctx>>::Known>;

+ E: Effect<'ctx>,

+ E: for<'a> Effect<'ctx>,

+ visitor: Visitor<'a, 'ctx>,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E>;

+ ) -> Future<'a, 'ctx, ControlFlow<(), Known<'a, 'ctx, Protocol>>, E>;

+ E: Effect<'ctx>,

+ E: Effect<'ctx>,

+ use crate::{

+ any::TypeNameable,

+ effect::{BlockOn, Blocking, Spin},

+ higher_ranked_type,

+ };

+ struct X<'ctx>(&'ctx mut i32);

+

+ #[derive(Debug)]

+ impl<'ctx, E> Hint<'ctx, Y, E> for X<'ctx>

+ where

+ E: Effect<'ctx>,

+ {

+ _visitor: Visitor<'a, 'ctx>,

+ _hint: <Y as HintMeta<'ctx>>::Hint,

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {

+ _hint: &'a <Y as HintMeta<'ctx>>::Hint,

+ ) -> Future<'a, 'ctx, ControlFlow<(), Known<'a, 'ctx, Y>>, E> {

+ E::wrap(async { ControlFlow::Continue(&mut *self.0) })

+ higher_ranked_type! {

+ type KnownHkt['ctx]: (AnySend) = for<'lt> &'lt mut i32

+ }

+ let mut z = 42;

+ let mut x = X(&mut z);

+ let y: &mut dyn Hint<'_, Y, Blocking> = &mut x;

+ fn id<'a, 'ctx, T: ?Sized + TypeNameable<'a, 'ctx>>(_x: &T) {}

+

+ let x = Spin::block_on(y.known(&()));

+ match x {

+ ControlFlow::Continue(value) => *value += 1,

+ ControlFlow::Break(_) => todo!(),

+ }

+ assert_eq!(z, 43);

+ build::Builder,

+ effect::{Effect, Future},

+#[inline]

+pub fn transform<

+ 'a,

+ 'ctx,

+ B: Builder<'ctx, Effect = E> + 'a,

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

+ E: Effect<'ctx>,

+>(

+ seed: B::Seed,

+ walker: W,

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

+ E::wrap(async {

+ // Create builder from seed value;

+ let mut builder = B::from_seed(seed).await;

+ // Walk the walker with the builder as the visitor.

+ let walker_result = walker.walk(builder.as_visitor()).await;

+

+ // Finish building the value.

+ let builder_result = builder.build().await;

+ (builder_result, walker_result)

+ })

+ effect::{Effect, Future},

+pub trait Walk<'ctx>: WalkerTypes<'ctx> + Sized {

+ type Walker<E: Effect<'ctx>>: Walker<'ctx, Error = Self::Error, Output = Self::Output, Effect = E>;

+

+ fn into_walker<E: Effect<'ctx>>(self) -> Self::Walker<E>;

+pub trait WalkerTypes<'ctx> {

+ type Error: Send;

+

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

+ ///

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

+ type Output: Send;

+pub trait Walker<'ctx>: WalkerTypes<'ctx> + Send {

+ type Effect: Effect<'ctx>;

+ visitor: Visitor<'a, 'ctx>,

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

+ Self: 'a;

+// pub mod array;

+use crate::{any::static_wrapper::OwnedStatic, protocol::visitor::value::Value};

+use core::{marker::PhantomData, mem::MaybeUninit, ops::ControlFlow};

+ effect::{Effect, Future},

+ walker::hint::{Hint, HintMeta},

+ type Walker<E: Effect<'ctx>> = Walker<E>;

+ fn into_walker<E: Effect<'ctx>>(self) -> Self::Walker<E> {

+ Walker(self, PhantomData)

+pub struct Walker<E>(bool, PhantomData<fn() -> E>);

+

+impl<'ctx> crate::WalkerTypes<'ctx> for bool {

+ type Error = ();

+

+ type Output = ();

+}

+impl<'ctx, E: Effect<'ctx>> crate::WalkerTypes<'ctx> for Walker<E> {

+}

+impl<'ctx, E: Effect<'ctx>> crate::Walker<'ctx> for Walker<E> {

+ type Effect = E;

+ visitor: Visitor<'a, 'ctx>,

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

+ E::wrap(async move {

+ visitor.upcast_mut::<dyn Value<'_, 'ctx, OwnedStatic<bool>, E> + '_>()

+ object.visit(OwnedStatic(self.0)).await;

+ })

+use std::{marker::PhantomData, ops::ControlFlow, pin::Pin, thread::yield_now, time::Duration};

+ effect::{BlockOn, Blocking, Effect, Future, Spin},

+ protocol::visitor::value::Value,

+ protocol::Visitor,

+ transform, Build, Builder, Walk, Walker, builders::core::option::IgnoreMissing, WalkerTypes,

+ let hook = Hook::<_, Blocking> {

+ inner: true.into_walker::<Blocking>(),

+ // let x = Spin::block_on(transform::<<Option<bool> as Build>::Builder<_>, _, Blocking>(IgnoreMissing::No, hook));

+ let x = Spin::block_on(transform::<<bool as Build>::Builder<_>, _, Blocking>((), hook));

+ let hook = Hook::<_, Blocking> {

+ inner: x.into_walker::<Blocking>(),

+ Spin::block_on(transform::<<bool as Build>::Builder<_>, _, Blocking>(

+ (),

+ hook,

+ ))

+ .0

+ .unwrap()

+struct Hook<T, E> {

+ _marker: PhantomData<fn() -> E>,

+struct VisitorHook<'a, 'ctx: 'a, E> {

+ inner: Visitor<'a, 'ctx>,

+ _marker: PhantomData<fn() -> E>,

+impl<'ctx, T: Walker<'ctx, Effect = E>, E: Effect<'ctx>> WalkerTypes<'ctx> for Hook<T, E> {

+}

+

+impl<'ctx, T: Walker<'ctx, Effect = E>, E: Effect<'ctx>> Walker<'ctx> for Hook<T, E> {

+ type Effect = E;

+ visitor: Visitor<'a, 'ctx>,

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

+ E::wrap(async {

+ let mut visitor = VisitorHook::<E> {

+ inner: visitor,

+ _marker: PhantomData,

+ };

+impl<'b, 'ctx: 'b, E: Effect<'ctx>> AnyTrait<'ctx> for VisitorHook<'b, 'ctx, E> {

+ id => self.inner.upcast_to_id(id),

+ id if id == LtTypeId::of::<dyn Value<'a, 'ctx, OwnedStatic<bool>, E> + 'a>() => {

+ // println!("hook: {:?}", id);

+ if self.inner.upcast_to_id_mut(id).is_some() {

+ dyn Value<'a, 'ctx, OwnedStatic<bool>, E> + 'a,

+ id => {

+ // println!("fallback: {:?}", id);

+ self.inner.upcast_to_id_mut(id)

+ },

+impl<'a, 'b, 'ctx: 'a + 'b, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<bool>, E> for VisitorHook<'b, 'ctx, E> {

+ ) -> Future<'a, 'ctx, ControlFlow<(), ()>, E> {