Trait conch_runtime::future::EnvFuture
[−]
[src]
pub trait EnvFuture<E: ?Sized> { type Item; type Error; fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>; fn cancel(&mut self, env: &mut E); fn pin_env(self, env: E) -> Pinned<E, Self>
where
E: Sized,
Self: Sized, { ... } fn fuse(self) -> Fuse<Self>
where
Self: Sized, { ... } fn boxed_result<'a>(self) -> BoxedResult<'a, Self>
where
Self: Sized,
Self::Item: 'a + Future, { ... } }
A trait for objects that behave exactly like the Future
trait from the
futures
crate, however, each object must be polled in the context of some
environment.
Note that
EnvFuture
differs fromFuture
when it comes to dropping or cancelling: callers may need to ensure they callcancel
on theEnvFuture
before dropping it to ensure all environment state has been reset correctly. See documentation onpoll
andcancel
for more details.
Associated Types
type Item
The type of value that this future will resolved with if it is successful.
type Error
The type of error that this future will resolve with if it fails in a normal fashion.
Required Methods
fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>
Behaves identical to Future::poll
when polled with a provided environment.
Caller should take care to always poll this future with the same environment. An implementation may panic or yield incorrect results if it is polled with different environments.
Panics
Once a future has completed (returned Ready
or Err
from poll
, or
cancel
invoked), then any future calls to poll
may panic, block
forever, or otherwise cause wrong behavior. The EnvFuture
trait itself
provides no guarantees about the behavior of poll
after a future has completed.
Callers who may call poll
too many times may want to consider using
the fuse
adaptor which defines the behavior of poll
, but comes with
a little bit of extra cost.
Additionally, calls to poll
must always be made from within the
context of a task. If a current task is not set then this method will
likely panic.
fn cancel(&mut self, env: &mut E)
Cancel a future and consider it as completed, thus giving it a chance to run any clean up as if it had resolved on its own.
Although dropping an EnvFuture
will effectively cancel it by freeing
all resources and not doing any further work, there is no guarantee
that the future may not have made temporary changes to the environment
it wishes to undo (e.g. temporarily overriding a file descriptor).
Thus if a caller cares about returning the environment to a valid state,
they must call cancel
before dropping the future. Cancelling a future
which has never been polled is considered a valid use case, and should
be supported by the implementation.
Caller should take care to cancel this future with the same environment
that was provided to poll
. An implementation may panic or yield
incorrect results if it is polled with a different environment.
Panics
If a future has completed (returned Ready
or Err
from poll
, or
cancel
invoked) then any future calls to cancel
may panic, block
forever, or otherwise cause wrong behavior. The EnvFuture
trait itself
provides no guarantees about the behavior of cancel
after a future has
completed.
Callers who may call cancel
too many times may want to consider using
the fuse
adaptor which defines the behavior of cancel
, but comes
with a little bit of extra cost.
Provided Methods
fn pin_env(self, env: E) -> Pinned<E, Self> where
E: Sized,
Self: Sized,
E: Sized,
Self: Sized,
Pin an environment to this future, allowing the resulting future to be polled from anywhere without needing the caller to specify an environment.
fn fuse(self) -> Fuse<Self> where
Self: Sized,
Self: Sized,
Fuse a future such that poll
and cancel
will never again be called
once it has completed.
Currently once a future has returned Ready
or Err
from
poll
or if cancel
was invoked, any further calls to either method
could exhibit bad behavior such as blocking forever, panicking, never
returning, etc. If it is known that poll
or cancel
may be called too
often then this method can be used to ensure that it has defined semantics.
Once a future has been fuse
d and it returns a completion from poll
or cancelled via cancel, then it will forever return
NotReadyfrom
poll(never resolve) and will ignore future calls to
cancel. This, unlike the trait's
polland
cancel` methods, is guaranteed.
fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
Self: Sized,
Self::Item: 'a + Future,
Self: Sized,
Self::Item: 'a + Future,
Converts the resulting future into a boxed trait object.
In other words, instead of returning a concrete type, this
adapter will return Box<Future>
which is useful when type
erasure is desired.
Implementations on Foreign Types
impl<'a, T: ?Sized, E: ?Sized> EnvFuture<E> for &'a mut T where
T: EnvFuture<E>,
[src]
T: EnvFuture<E>,
type Item = T::Item
type Error = T::Error
fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>
[src]
fn cancel(&mut self, env: &mut E)
[src]
fn pin_env(self, env: E) -> Pinned<E, Self> where
E: Sized,
Self: Sized,
[src]
E: Sized,
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
Self: Sized,
Self::Item: 'a + Future,
[src]
Self: Sized,
Self::Item: 'a + Future,
impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Box<T> where
T: EnvFuture<E>,
[src]
T: EnvFuture<E>,
type Item = T::Item
type Error = T::Error
fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>
[src]
fn cancel(&mut self, env: &mut E)
[src]
fn pin_env(self, env: E) -> Pinned<E, Self> where
E: Sized,
Self: Sized,
[src]
E: Sized,
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
Self: Sized,
Self::Item: 'a + Future,
[src]
Self: Sized,
Self::Item: 'a + Future,
impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Option<OwnedSpawnRefRc<T, E>> where
T: 'static + SpawnBoxed<E>,
E: 'static,
[src]
T: 'static + SpawnBoxed<E>,
E: 'static,
type Item = BoxStatusFuture<'static, Self::Error>
type Error = T::Error
fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>
[src]
fn cancel(&mut self, env: &mut E)
[src]
fn pin_env(self, env: E) -> Pinned<E, Self> where
E: Sized,
Self: Sized,
[src]
E: Sized,
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
Self: Sized,
Self::Item: 'a + Future,
[src]
Self: Sized,
Self::Item: 'a + Future,
impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Option<OwnedSpawnRefArc<T, E>> where
T: 'static + SpawnBoxed<E>,
E: 'static,
[src]
T: 'static + SpawnBoxed<E>,
E: 'static,
type Item = BoxStatusFuture<'static, Self::Error>
type Error = T::Error
fn poll(&mut self, env: &mut E) -> Poll<Self::Item, Self::Error>
[src]
fn cancel(&mut self, env: &mut E)
[src]
fn pin_env(self, env: E) -> Pinned<E, Self> where
E: Sized,
Self: Sized,
[src]
E: Sized,
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
Self: Sized,
Self::Item: 'a + Future,
[src]
Self: Sized,
Self::Item: 'a + Future,
Implementors
impl<W, I, E: ?Sized> EnvFuture<E> for Concat<W, I, E> where
W: WordEval<E>,
I: Iterator<Item = W>, type Item = Fields<W::EvalResult>; type Error = W::Error;impl<T, W, I, E: ?Sized> EnvFuture<E> for DoubleQuoted<T, W, W::EvalFuture, I> where
T: StringWrapper,
W: WordEval<E, EvalResult = T>,
I: Iterator<Item = W>,
E: VariableEnvironment<Var = T>,
E::VarName: Borrow<String>, type Item = Fields<T>; type Error = W::Error;impl<T, F, E: ?Sized> EnvFuture<E> for Alternative<F> where
F: EnvFuture<E, Item = Fields<T>>, type Item = F::Item; type Error = F::Error;impl<T, F, E: ?Sized> EnvFuture<E> for Assign<T, F> where
T: StringWrapper,
F: EnvFuture<E, Item = Fields<T>>,
F::Error: From<ExpansionError>,
E: VariableEnvironment<VarName = T, Var = T>, type Item = Fields<T>; type Error = F::Error;impl<T, F, E: ?Sized> EnvFuture<E> for EvalDefault<T, F> where
F: EnvFuture<E, Item = Fields<T>>, type Item = F::Item; type Error = F::Error;impl<T, FT, F, E: ?Sized> EnvFuture<E> for Error<T, F> where
FT: StringWrapper,
F: EnvFuture<E, Item = Fields<FT>>,
F::Error: From<ExpansionError>,
E: VariableEnvironment, type Item = Fields<T>; type Error = F::Error;impl<T, T2, F, E: ?Sized> EnvFuture<E> for RemoveSmallestSuffix<T, F> where
T: StringWrapper,
T2: StringWrapper,
F: EnvFuture<E, Item = Fields<T2>>, type Item = Fields<T>; type Error = F::Error;impl<T, T2, F, E: ?Sized> EnvFuture<E> for RemoveLargestSuffix<T, F> where
T: StringWrapper,
T2: StringWrapper,
F: EnvFuture<E, Item = Fields<T2>>, type Item = Fields<T>; type Error = F::Error;impl<T, T2, F, E: ?Sized> EnvFuture<E> for RemoveSmallestPrefix<T, F> where
T: StringWrapper,
T2: StringWrapper,
F: EnvFuture<E, Item = Fields<T2>>, type Item = Fields<T>; type Error = F::Error;impl<T, T2, F, E: ?Sized> EnvFuture<E> for RemoveLargestPrefix<T, F> where
T: StringWrapper,
T2: StringWrapper,
F: EnvFuture<E, Item = Fields<T2>>, type Item = Fields<T>; type Error = F::Error;impl<T, F, E: ?Sized> EnvFuture<E> for Split<F> where
T: StringWrapper,
F: EnvFuture<E, Item = Fields<T>>,
E: VariableEnvironment,
E::VarName: Borrow<String>,
E::Var: Borrow<String>, type Item = F::Item; type Error = F::Error;impl<T, F, E: ?Sized> EnvFuture<E> for Redirect<F> where
T: StringWrapper,
F: EnvFuture<E, Item = Fields<T>>,
F::Error: From<RedirectionError>,
E: FileDescEnvironment + IsInteractiveEnvironment + WorkingDirectoryEnvironment,
E::FileHandle: Clone + From<FileDesc>, type Item = RedirectAction<E::FileHandle>; type Error = F::Error;impl<R, W, I, E: ?Sized, RR> EnvFuture<E> for EvalRedirectOrCmdWord<R, W, I, E, RR> where
I: Iterator<Item = RedirectOrCmdWord<R, W>>,
R: RedirectEval<E, Handle = E::FileHandle>,
R::Error: From<RedirectionError>,
W: WordEval<E>,
E: AsyncIoEnvironment + FileDescEnvironment,
E::FileHandle: From<FileDesc>,
RR: RedirectEnvRestorer<E>, type Item = (RR, Vec<W::EvalResult>); type Error = EvalRedirectOrCmdWordError<R::Error, W::Error>;impl<R, V, W, I, E: ?Sized, RR> EnvFuture<E> for EvalRedirectOrVarAssig<R, V, W, I, E, RR> where
I: Iterator<Item = RedirectOrVarAssig<R, V, W>>,
R: RedirectEval<E, Handle = E::FileHandle>,
R::Error: From<RedirectionError>,
V: Hash + Eq,
W: WordEval<E>,
E: AsyncIoEnvironment + FileDescEnvironment + VariableEnvironment,
E::FileHandle: From<FileDesc> + Borrow<FileDesc>,
E::VarName: Borrow<String>,
E::Var: Borrow<String>,
RR: RedirectEnvRestorer<E>, type Item = (RR, HashMap<V, W::EvalResult>); type Error = EvalRedirectOrVarAssigError<R::Error, W::Error>;impl<R, V, W, I, E: ?Sized, RR, VR> EnvFuture<E> for EvalRedirectOrVarAssig2<R, V, W, I, E, RR, VR> where
I: Iterator<Item = RedirectOrVarAssig<R, V, W>>,
R: RedirectEval<E, Handle = E::FileHandle>,
R::Error: From<RedirectionError>,
V: Hash + Eq,
W: WordEval<E>,
E: AsyncIoEnvironment + FileDescEnvironment + VariableEnvironment,
E::FileHandle: From<FileDesc> + Borrow<FileDesc>,
E::VarName: Borrow<String> + From<V>,
E::Var: Borrow<String> + From<W::EvalResult>,
RR: RedirectEnvRestorer<E>,
VR: VarEnvRestorer2<E>, type Item = (RR, VR); type Error = EvalRedirectOrVarAssigError<R::Error, W::Error>;impl<W, I, E: ?Sized> EnvFuture<E> for ComplexWord<W, I, E> where
W: WordEval<E>,
I: Iterator<Item = W>, type Item = Fields<W::EvalResult>; type Error = W::Error;impl<T, F, I, A, E> EnvFuture<E> for ParameterSubstitution<T, F, I, A, E, E::Read> where
T: StringWrapper,
F: EnvFuture<E, Item = Fields<T>>,
F::Error: From<ExpansionError> + From<<I::Item as Spawn<E>>::Error>,
I: Iterator,
I::Item: Spawn<E>,
<I::Item as Spawn<E>>::Error: IsFatalError + From<IoError>,
A: ArithEval<E>,
E: AsyncIoEnvironment + FileDescEnvironment + LastStatusEnvironment + ReportErrorEnvironment + SubEnvironment + VariableEnvironment<VarName = T, Var = T>,
E::FileHandle: FileDescWrapper, type Item = Fields<T>; type Error = F::Error;impl<E: ?Sized, T, F> EnvFuture<E> for SimpleWord<T, F> where
F: EnvFuture<E, Item = Fields<T>>, type Item = Fields<T>; type Error = F::Error;impl<T, W, I, E: ?Sized> EnvFuture<E> for Word<T, W, W::EvalFuture, I> where
T: StringWrapper,
W: WordEval<E, EvalResult = T>,
I: Iterator<Item = W>,
E: VariableEnvironment<Var = T>,
E::VarName: Borrow<String>, type Item = Fields<T>; type Error = W::Error;impl<E: ?Sized, T, F> EnvFuture<E> for Assignment<F> where
E: VariableEnvironment,
E::VarName: Borrow<String>,
E::Var: Borrow<String>,
T: StringWrapper,
F: EnvFuture<E, Item = Fields<T>>, type Item = T; type Error = F::Error;impl<E: ?Sized, T, F> EnvFuture<E> for Pattern<F> where
F: EnvFuture<E, Item = Fields<T>>,
T: StringWrapper, type Item = Pattern; type Error = F::Error;impl<'a, EF, F, E: ?Sized> EnvFuture<E> for BoxedResult<'a, EF> where
EF: EnvFuture<E, Item = F>,
F: 'a + Future,
F::Error: From<EF::Error>, type Item = Box<Future<Item = F::Item, Error = F::Error> + 'a>; type Error = F::Error;impl<E: ?Sized, F: EnvFuture<E>> EnvFuture<E> for Fuse<F> type Item = F::Item; type Error = F::Error;
impl<T, I, E: ?Sized> EnvFuture<E> for AndOrList<T, I, E> where
T: Spawn<E>,
T::Error: IsFatalError,
I: Iterator<Item = AndOr<T>>,
E: LastStatusEnvironment + ReportErrorEnvironment, type Item = ExitResult<T::Future>; type Error = T::Error;impl<W, S, IA, IW, IS, E: ?Sized> EnvFuture<E> for Case<IA, IW, IS, E> where
IA: Iterator<Item = PatternBodyPair<IW, IS>>,
IW: IntoIterator<Item = W>,
W: WordEval<E>,
W::Error: IsFatalError,
IS: IntoIterator<Item = S>,
S: Spawn<E>,
S::Error: From<W::Error> + IsFatalError,
E: LastStatusEnvironment + ReportErrorEnvironment, type Item = ExitResult<S::Future>; type Error = S::Error;impl<I, W, S, E: ?Sized> EnvFuture<E> for For<I, S, E> where
I: Iterator<Item = W>,
W: WordEval<E>,
W::EvalResult: Into<E::Var>,
S: SpawnRef<E>,
S::Error: From<W::Error> + IsFatalError,
E: LastStatusEnvironment + ReportErrorEnvironment + VariableEnvironment,
E::VarName: Clone, type Item = ExitResult<S::Future>; type Error = S::Error;impl<I, S, E: ?Sized> EnvFuture<E> for ForArgs<I, S, E> where
I: Iterator<Item = E::Var>,
S: SpawnRef<E>,
S::Error: IsFatalError,
E: LastStatusEnvironment + ReportErrorEnvironment + VariableEnvironment,
E::VarName: Clone, type Item = ExitResult<S::Future>; type Error = S::Error;impl<S, E: ?Sized> EnvFuture<E> for Function<S, E> where
S: Spawn<E>,
E: SetArgumentsEnvironment, type Item = S::Future; type Error = S::Error;impl<S, C, I, E: ?Sized> EnvFuture<E> for If<C, I, E> where
E: LastStatusEnvironment + ReportErrorEnvironment,
C: Iterator<Item = GuardBodyPair<I>>,
I: IntoIterator<Item = S>,
S: Spawn<E>,
S::Error: IsFatalError, type Item = ExitResult<S::Future>; type Error = S::Error;impl<R, I, S, E: ?Sized, RR> EnvFuture<E> for LocalRedirections<I, S, E, RR> where
R: RedirectEval<E, Handle = E::FileHandle>,
I: Iterator<Item = R>,
S: Spawn<E>,
S::Error: From<RedirectionError> + From<R::Error>,
E: AsyncIoEnvironment + FileDescEnvironment,
E::FileHandle: Clone + From<FileDesc>,
RR: RedirectEnvRestorer<E>, type Item = S::Future; type Error = S::Error;impl<S, E: ?Sized> EnvFuture<E> for Loop<S, E> where
S: SpawnRef<E>,
S::Error: IsFatalError,
E: LastStatusEnvironment + ReportErrorEnvironment, type Item = ExitStatus; type Error = S::Error;impl<S, E> EnvFuture<E> for Pipeline<S, E> where
S: Spawn<E>,
S::Error: From<Error>,
E: FileDescEnvironment + SubEnvironment,
E::FileHandle: From<FileDesc> + Clone, type Item = ExitResult<SpawnedPipeline<S, E>>; type Error = S::Error;impl<S, I, E: ?Sized> EnvFuture<E> for Sequence<I, E> where
E: LastStatusEnvironment + ReportErrorEnvironment,
I: Iterator<Item = S>,
S: Spawn<E>,
S::Error: IsFatalError, type Item = ExitResult<S::Future>; type Error = S::Error;impl<R, V, W, IV, IW, E: ?Sized, S> EnvFuture<E> for SimpleCommand<R, V, W, IV, IW, E> where
IV: Iterator<Item = RedirectOrVarAssig<R, V, W>>,
IW: Iterator<Item = RedirectOrCmdWord<R, W>>,
R: RedirectEval<E, Handle = E::FileHandle>,
R::Error: From<RedirectionError>,
V: Hash + Eq + Borrow<String>,
W: WordEval<E>,
S: Clone + Spawn<E>,
S::Error: From<CommandError> + From<RedirectionError> + From<R::Error> + From<W::Error>,
E: AsyncIoEnvironment + ExecutableEnvironment + ExportedVariableEnvironment + FileDescEnvironment + FunctionEnvironment<Fn = S> + SetArgumentsEnvironment + UnsetVariableEnvironment + WorkingDirectoryEnvironment,
E::Arg: From<W::EvalResult>,
E::Args: From<Vec<E::Arg>>,
E::FileHandle: FileDescWrapper,
E::FnName: From<W::EvalResult>,
E::VarName: Borrow<String> + Clone + From<V>,
E::Var: Borrow<String> + Clone + From<W::EvalResult>, type Item = ExitResult<SpawnedSimpleCommand<E::Future, S::Future>>; type Error = S::Error;impl<I, S, E> EnvFuture<E> for SubstitutionEnvFuture<I> where
I: Iterator<Item = S>,
S: Spawn<E>,
S::Error: IsFatalError + From<IoError>,
E: AsyncIoEnvironment + FileDescEnvironment + LastStatusEnvironment + ReportErrorEnvironment + SubEnvironment,
E::FileHandle: FileDescWrapper,
E::Read: AsyncRead, type Item = Substitution<I, E::Read, E>; type Error = S::Error;impl<F, E: ?Sized> EnvFuture<E> for SwallowNonFatal<F> where
F: EnvFuture<E>,
F::Item: From<ExitStatus>,
F::Error: IsFatalError,
E: LastStatusEnvironment + ReportErrorEnvironment, type Item = F::Item; type Error = F::Error;impl<T, I, E: ?Sized> EnvFuture<E> for SpawnedCd<I> where
T: StringWrapper,
I: Iterator<Item = T>,
E: AsyncIoEnvironment + ChangeWorkingDirectoryEnvironment + FileDescEnvironment + ReportErrorEnvironment + VariableEnvironment + WorkingDirectoryEnvironment,
E::FileHandle: Borrow<FileDesc>,
E::VarName: Borrow<String> + From<String>,
E::Var: Borrow<String> + From<String>, type Item = ExitResult<CdFuture<E::WriteAll>>; type Error = Void;impl<E: ?Sized> EnvFuture<E> for SpawnedColon type Item = ExitStatus; type Error = Void;
impl<T, I, E: ?Sized> EnvFuture<E> for SpawnedEcho<I> where
T: StringWrapper,
I: Iterator<Item = T>,
E: AsyncIoEnvironment + FileDescEnvironment + ReportErrorEnvironment,
E::FileHandle: Borrow<FileDesc>, type Item = ExitResult<EchoFuture<E::WriteAll>>; type Error = Void;impl<E: ?Sized> EnvFuture<E> for SpawnedFalse type Item = ExitStatus; type Error = Void;
impl<T, I, E: ?Sized> EnvFuture<E> for SpawnedPwd<I> where
T: StringWrapper,
I: Iterator<Item = T>,
E: AsyncIoEnvironment + FileDescEnvironment + ReportErrorEnvironment + WorkingDirectoryEnvironment,
E::FileHandle: Borrow<FileDesc>, type Item = ExitResult<PwdFuture<E::WriteAll>>; type Error = Void;impl<T, I, E: ?Sized> EnvFuture<E> for SpawnedShift<I> where
T: StringWrapper,
I: Iterator<Item = T>,
E: ArgumentsEnvironment + ShiftArgumentsEnvironment + ReportErrorEnvironment, type Item = ExitStatus; type Error = Void;impl<E: ?Sized> EnvFuture<E> for SpawnedTrue type Item = ExitStatus; type Error = Void;
impl<E: ?Sized, F> EnvFuture<E> for Command<F> where
F: EnvFuture<E>,
F::Error: From<RuntimeError>,
E: LastStatusEnvironment, type Item = F::Item; type Error = F::Error;impl<S, W, IS, IW, IG, IP, SR, E> EnvFuture<E> for CompoundCommandKindFuture<IS, IW, IG, IP, SR, E> where
S: Spawn<E>,
S::Error: From<W::Error> + IsFatalError,
W: WordEval<E>,
W::EvalResult: Into<E::Var>,
W::Error: IsFatalError,
IS: Iterator<Item = S>,
IW: Iterator<Item = W>,
IG: Iterator<Item = GuardBodyPair<IS>>,
IP: Iterator<Item = PatternBodyPair<IW, IS>>,
SR: SpawnRef<E, Error = S::Error>,
E: LastStatusEnvironment + ReportErrorEnvironment + VariableEnvironment + SubEnvironment,
E::VarName: Clone, type Item = ExitResult<Either<S::Future, SR::Future>>; type Error = S::Error;impl<S, E> EnvFuture<E> for ListableCommand<S, E> where
S: Spawn<E>,
S::Error: From<Error>,
E: FileDescEnvironment + SubEnvironment,
E::FileHandle: From<FileDesc> + Clone, type Item = ExitResult<SpawnedPipeline<S, E>>; type Error = S::Error;impl<N, S, C, F, E: ?Sized> EnvFuture<E> for PipeableCommand<N, S, C, F> where
S: EnvFuture<E>,
C: EnvFuture<E, Error = S::Error>,
E: FunctionEnvironment,
E::FnName: From<N>,
E::Fn: From<F>, type Item = ExitResult<Either<S::Item, C::Item>>; type Error = S::Error;impl<E: ?Sized> EnvFuture<E> for ExitStatus type Item = Self; type Error = Void;