Trait conch_runtime::future::EnvFuture

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 from Future when it comes to dropping or cancelling: callers may need to ensure they call cancel on the EnvFuture before dropping it to ensure all environment state has been reset correctly. See documentation on poll and cancel 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, 

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, 

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 fused and it returns a completion from poll or cancelled via cancel, then it will forever returnNotReadyfrompoll(never resolve) and will ignore future calls tocancel. This, unlike the trait'spollandcancel` methods, is guaranteed.

fn boxed_result<'a>(self) -> BoxedResult<'a, Self> where
    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>, 

type Item = T::Item

type Error = T::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, 

impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Box<T> where
    T: EnvFuture<E>, 

type Item = T::Item

type Error = T::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, 

impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Option<OwnedSpawnRefRc<T, E>> where
    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>

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, 

impl<T: ?Sized, E: ?Sized> EnvFuture<E> for Option<OwnedSpawnRefArc<T, E>> where
    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>

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, 

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;