error.log

   Compiling async-error-repro v0.1.0 (/tmp/async-error-repro)
warning: unused import: `core::pin::pin`
 --> src/main.rs:1:5
  |
1 | use core::pin::pin;
  |     ^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `Future`
 --> src/main.rs:4:15
  |
4 | use futures::{Future, Stream, StreamExt, TryStreamExt};
  |               ^^^^^^

warning: unused import: `Resource`
  --> src/main.rs:12:18
   |
12 |     Api, Client, Resource,
   |                  ^^^^^^^^

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]` cannot be unpinned
    --> src/main.rs:52:40
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                        ^^^^^^^^ within `utils::_::__OnComplete<'_, futures::stream::AndThen<utils::OnComplete<impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `try_next`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/futures-util-0.3.28/src/stream/try_stream/mod.rs:392:15
     |
392  |         Self: Unpin,
     |               ^^^^^ required by this bound in `TryStreamExt::try_next`

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]` cannot be unpinned
    --> src/main.rs:52:40
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                        ^^^^^^^^ within `futures::stream::try_stream::and_then::_::__Origin<'_, utils::OnComplete<impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `Option<[async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]>`
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `try_next`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/futures-util-0.3.28/src/stream/try_stream/mod.rs:392:15
     |
392  |         Self: Unpin,
     |               ^^^^^ required by this bound in `TryStreamExt::try_next`

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]` cannot be unpinned
    --> src/main.rs:52:40
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                        ^^^^^^^^ within `utils::_::__OnComplete<'_, impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `try_next`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/futures-util-0.3.28/src/stream/try_stream/mod.rs:392:15
     |
392  |         Self: Unpin,
     |               ^^^^^ required by this bound in `TryStreamExt::try_next`

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]` cannot be unpinned
    --> src/main.rs:52:40
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                        ^^^^^^^^ within `utils::_::__OnComplete<'_, futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`
     = note: required for `OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<...>>, ...>, ..., ..., ...>, ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-7699132640600909485.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>`
     = note: required for `IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<..., ...>, ..., ..., ...>, ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9703902725394187167.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>, fn(&mut PollNext) -> PollNext, PollNext>`
     = note: required for `SelectWithStrategy<IntoStream<OnComplete<Map<Runner<..., ..., ..., ..., ...>, ...>, ...>>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11886866254827876509.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>>`
     = note: required for `Select<IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, ..., ..., ..., ...>, ...>, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8011314318438810661.txt'
note: required because it appears within the type `impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/utils/mod.rs:139:6
     |
139  | ) -> impl Stream<Item = Result<S2::Ok, S1::Error>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>>`
     = note: required for `Fuse<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3578533893271782640.txt'
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `try_next`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/futures-util-0.3.28/src/stream/try_stream/mod.rs:392:15
     |
392  |         Self: Unpin,
     |               ^^^^^ required by this bound in `TryStreamExt::try_next`

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]` cannot be unpinned
    --> src/main.rs:52:40
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                        ^^^^^^^^ within `futures::future::future::fuse::_::__Origin<'_, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `Option<[async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required because it appears within the type `__Origin<'_, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required for `Fuse<[async block@applier<Pod, TakeUntil<..., ...>, ..., ..., ..., ...>::{closure#3}::{closure#1}]>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11708895589785762600.txt'
     = note: required because it appears within the type `__Runner<'_, ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required for `Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<..., ...>>>>, ...>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3851773992535840451.txt'
     = note: required because it appears within the type `__Origin<'_, Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>`
     = note: required for `Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<..., ...>>>>, ...>, ..., ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11474861280030344234.txt'
     = note: required because it appears within the type `__Origin<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>>`
     = note: required for `Fuse<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<...>>>, ...>, ..., ..., ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9507801876277428673.txt'
     = note: required because it appears within the type `__OnComplete<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`
     = note: required for `OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<...>>, ...>, ..., ..., ...>, ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-7699132640600909485.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>`
     = note: required for `IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<..., ...>, ..., ..., ...>, ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9703902725394187167.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>, fn(&mut PollNext) -> PollNext, PollNext>`
     = note: required for `SelectWithStrategy<IntoStream<OnComplete<Map<Runner<..., ..., ..., ..., ...>, ...>, ...>>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11886866254827876509.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>>`
     = note: required for `Select<IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, ..., ..., ..., ...>, ...>, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8011314318438810661.txt'
note: required because it appears within the type `impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/utils/mod.rs:139:6
     |
139  | ) -> impl Stream<Item = Result<S2::Ok, S1::Error>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>>`
     = note: required for `Fuse<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3578533893271782640.txt'
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `try_next`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/futures-util-0.3.28/src/stream/try_stream/mod.rs:392:15
     |
392  |         Self: Unpin,
     |               ^^^^^ required by this bound in `TryStreamExt::try_next`

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]` cannot be unpinned
    --> src/main.rs:52:50
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                                  ^^^^^^
     |                                                  |
     |                                                  within `utils::_::__OnComplete<'_, futures::stream::AndThen<utils::OnComplete<impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]`
     |                                                  help: remove the `.await`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `futures::Future`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `std::future::IntoFuture`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]` cannot be unpinned
    --> src/main.rs:52:50
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                                  ^^^^^^
     |                                                  |
     |                                                  within `futures::stream::try_stream::and_then::_::__Origin<'_, utils::OnComplete<impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]`
     |                                                  help: remove the `.await`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `Option<[async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}]>`
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `futures::Future`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `std::future::IntoFuture`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]` cannot be unpinned
    --> src/main.rs:52:50
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                                  ^^^^^^
     |                                                  |
     |                                                  within `utils::_::__OnComplete<'_, impl Stream<Item = Result<<utils::OnComplete<futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]`
     |                                                  help: remove the `.await`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `futures::Future`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `std::future::IntoFuture`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]` cannot be unpinned
    --> src/main.rs:52:50
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                                  ^^^^^^
     |                                                  |
     |                                                  within `utils::_::__OnComplete<'_, futures::stream::Map<controller::runner::Runner<ReconcileRequest<Pod>, utils::SplitCase<futures::stream::IntoStream<Pin<Box<futures::stream::Select<utils::OnComplete<futures::stream::MapOk<futures::stream::MapErr<TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, fn(kube::kube_runtime::watcher::Error) -> kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error> {kube::kube_runtime::controller::Error::<MyError, kube::kube_runtime::watcher::Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, utils::OnComplete<TakeUntil<futures::stream::Map<futures::futures_channel::mpsc::Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>::Ok}>, futures::futures_channel::oneshot::Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<tracing::instrument::Instrumented<futures::future::Then<futures::future::IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, futures::future::Map<controller::RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, futures::future::Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), kube::kube_runtime::controller::Error<MyError, kube::kube_runtime::watcher::Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]`
     |                                                  help: remove the `.await`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `__OnComplete<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`
     = note: required for `OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<...>>, ...>, ..., ..., ...>, ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-7699132640600909485.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>`
     = note: required for `IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<..., ...>, ..., ..., ...>, ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9703902725394187167.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>, fn(&mut PollNext) -> PollNext, PollNext>`
     = note: required for `SelectWithStrategy<IntoStream<OnComplete<Map<Runner<..., ..., ..., ..., ...>, ...>, ...>>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11886866254827876509.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>>`
     = note: required for `Select<IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, ..., ..., ..., ...>, ...>, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8011314318438810661.txt'
note: required because it appears within the type `impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/utils/mod.rs:139:6
     |
139  | ) -> impl Stream<Item = Result<S2::Ok, S1::Error>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>>`
     = note: required for `Fuse<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3578533893271782640.txt'
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `futures::Future`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `std::future::IntoFuture`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'

error[E0277]: `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]` cannot be unpinned
    --> src/main.rs:52:50
     |
52   |     while let Some(_item) = controller.try_next().await? {
     |                                                  ^^^^^^
     |                                                  |
     |                                                  within `futures::future::future::fuse::_::__Origin<'_, [async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`, the trait `Unpin` is not implemented for `[async block@applier<Pod, TakeUntil<StreamBackoff<futures::stream::SelectAll<Pin<Box<(dyn Stream<Item = Result<ReconcileRequest<Pod>, kube::kube_runtime::watcher::Error>> + std::marker::Send + 'static)>>>, Box<(dyn backoff::backoff::Backoff + std::marker::Send + 'static)>>, futures::future::SelectAll<Pin<Box<(dyn futures::Future<Output = ()> + std::marker::Send + 'static)>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl futures::Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl futures::Future<Output = Result<Action, MyError>> {reconcile}, for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], for<'a> fn(Arc<Pod>, &'a MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]`
     |                                                  help: remove the `.await`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
     = note: required because it appears within the type `Option<[async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required because it appears within the type `__Origin<'_, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required for `Fuse<[async block@applier<Pod, TakeUntil<..., ...>, ..., ..., ..., ...>::{closure#3}::{closure#1}]>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11708895589785762600.txt'
     = note: required because it appears within the type `__Runner<'_, ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>`
     = note: required for `Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<..., ...>>>>, ...>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3851773992535840451.txt'
     = note: required because it appears within the type `__Origin<'_, Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>`
     = note: required for `Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<..., ...>>>>, ...>, ..., ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11474861280030344234.txt'
     = note: required because it appears within the type `__Origin<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>>`
     = note: required for `Fuse<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<...>>>, ...>, ..., ..., ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9507801876277428673.txt'
     = note: required because it appears within the type `__OnComplete<'_, Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>`
     = note: required for `OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<...>>, ...>, ..., ..., ...>, ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-7699132640600909485.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>`
     = note: required for `IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<..., ...>, ..., ..., ...>, ...>, ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-9703902725394187167.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>, fn(&mut PollNext) -> PollNext, PollNext>`
     = note: required for `SelectWithStrategy<IntoStream<OnComplete<Map<Runner<..., ..., ..., ..., ...>, ...>, ...>>, ..., ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-11886866254827876509.txt'
     = note: required because it appears within the type `__Origin<'_, IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]>>, Map<SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, Error<MyError, Error>>, fn(Error<MyError, Error>) -> Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>> {Result::<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>::Err}>>`
     = note: required for `Select<IntoStream<OnComplete<Map<Runner<ReconcileRequest<Pod>, ..., ..., ..., ...>, ...>, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8011314318438810661.txt'
note: required because it appears within the type `impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/utils/mod.rs:139:6
     |
139  | ) -> impl Stream<Item = Result<S2::Ok, S1::Error>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>>`
     = note: required for `Fuse<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-3578533893271782640.txt'
     = note: required because it appears within the type `__OnComplete<'_, impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>`
     = note: required for `OnComplete<impl Stream<Item = Result<<OnComplete<Map<..., ...>, ...> as TryStream>::Ok, ...>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-16507140148601776339.txt'
     = note: required because it appears within the type `__Origin<'_, OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>`
     = note: required for `AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<..., ...> as TryStream>::Ok, ...>>, ...>, ..., ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-18060137773167968328.txt'
     = note: required because it appears within the type `__Origin<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>>`
     = note: required for `Fuse<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-5133280626136552956.txt'
     = note: required because it appears within the type `__OnComplete<'_, AndThen<OnComplete<impl Stream<Item = Result<<OnComplete<Map<Runner<ReconcileRequest<Pod>, SplitCase<IntoStream<Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>>>, ScheduleRequest<ReconcileRequest<Pod>>>, Either<Instrumented<Then<IntoFuture<CancelableJoinHandle<Result<Action, MyError>>>, Map<RescheduleReconciliation<Pod, MyError>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}::{closure#1}]>>, Ready<Result<(ObjectRef<Pod>, Result<Action, MyError>), Error<MyError, Error>>>>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#0}], [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#1}]>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#2}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#3}::{closure#3}]> as TryStream>::Ok, <Pin<Box<Select<OnComplete<MapOk<MapErr<TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, fn(Error) -> Error<MyError, Error> {Error::<MyError, Error>::QueueError}>, [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#1}]>, OnComplete<TakeUntil<Map<Receiver<ScheduleRequest<ReconcileRequest<Pod>>>, fn(ScheduleRequest<ReconcileRequest<Pod>>) -> Result<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>> {Result::<ScheduleRequest<ReconcileRequest<Pod>>, Error<MyError, Error>>::Ok}>, Receiver<()>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#2}]>>>> as TryStream>::Error>>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#4}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}::{closure#0}], [closure@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#5}]>, [async block@applier<Pod, TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>, CancelableJoinHandle<Result<Action, MyError>>, Context, [closure@Controller<Pod>::run<impl Future<Output = Result<Action, MyError>>, Context, fn(Arc<Pod>, Arc<Context>) -> impl Future<Output = Result<Action, MyError>> {reconcile}, fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#0}], fn(Arc<Pod>, &MyError, Arc<Context>) -> Action {error_policy}>::{closure#6}]>`
     = note: required for `OnComplete<AndThen<OnComplete<impl Stream<Item = Result<<... as TryStream>::Ok, ...>>, ...>, ..., ...>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-17306579076508337608.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:257:6
     |
257  | ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, QueueStream::Error>>>
     |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required because it appears within the type `__Origin<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<CancelableJoinHandle<Result<Action, MyError>> as TryFuture>::Error, <TakeUntil<StreamBackoff<SelectAll<Pin<Box<dyn Stream<Item = Result<ReconcileRequest<Pod>, Error>> + Send>>>, Box<dyn Backoff + Send>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>> as TryStream>::Error>>>, SelectAll<Pin<Box<dyn Future<Output = ()> + Send>>>>`
     = note: required for `TakeUntil<impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<... as TryFuture>::Error, ...>>>, ...>` to implement `Unpin`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-13463949772758701333.txt'
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<<impl Future<Output = Result<Action, MyError>> as TryFuture>::Error, Error>>>`
    --> /home/fra/.cargo/registry/src/index.crates.io-6f17d22bba15001f/kube-runtime-0.86.0/src/controller/mod.rs:1255:10
     |
1255 |     ) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<ReconcilerFut::Error, watcher::Error>>>
     |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required because it appears within the type `impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>`
    --> src/main.rs:34:13
     |
34   | ) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `futures::Future`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'
     = note: required for `TryNext<'_, impl Stream<Item = Result<(ObjectRef<Pod>, Action), Error<MyError, Error>>>>` to implement `std::future::IntoFuture`
     = note: the full type name has been written to '/tmp/async-error-repro/target/debug/deps/async_error_repro-1f993112a333ce0e.long-type-8993789202358720694.txt'

warning: unused import: `StreamExt`
 --> src/main.rs:4:31
  |
4 | use futures::{Future, Stream, StreamExt, TryStreamExt};
  |                               ^^^^^^^^^

For more information about this error, try `rustc --explain E0277`.
warning: `async-error-repro` (bin "async-error-repro") generated 4 warnings
error: could not compile `async-error-repro` (bin "async-error-repro") due to 10 previous errors; 4 warnings emitted