Struct MaybeResolved

pub struct MaybeResolved<T, F>(/* private fields */)
where
    F: IStable + Future<Output = T>,
    (): IStable + IDeterminantProvider<F>,
    T: IStable + IDeterminantProvider<Result<(), F>>,
    Result<(), F>: IStable;

A future that may have already been resolved from the moment it was constructed.

Implementations

impl<T, F> MaybeResolved<T, F>

where F: IStable + Future<Output = T>, (): IStable + IDeterminantProvider<F>, T: IStable + IDeterminantProvider<Result<(), F>>, Result<(), F>: IStable, Result<T, Result<(), F>>: IStable,

pub const fn has_optimal_layout() -> bool

Returns true if the layout for MaybeResolved is smaller than what #[repr(C)] would have generated for it.

impl<T, F> MaybeResolved<T, F>

where F: IStable + Future<Output = T>, (): IStable + IDeterminantProvider<F>, T: IStable + IDeterminantProvider<Result<(), F>>, Result<(), F>: IStable,

pub fn Resolved(value: T) -> MaybeResolved<T, F>

The future was resolved from its construction.

pub fn Empty() -> MaybeResolved<T, F>

The future has been consumed already.

pub fn Pending(value: F) -> MaybeResolved<T, F>

The future is yet to be resolved.

pub fn match_owned<StabbyOut, ResolvedFn, EmptyFn, PendingFn>( self, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(T) -> StabbyOut, EmptyFn: FnOnce() -> StabbyOut, PendingFn: FnOnce(F) -> StabbyOut,

Equivalent to match self.

pub fn match_ref<'st_lt, StabbyOut, ResolvedFn, EmptyFn, PendingFn>( &'st_lt self, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(&'st_lt T) -> StabbyOut, EmptyFn: FnOnce() -> StabbyOut, PendingFn: FnOnce(&'st_lt F) -> StabbyOut,

Equivalent to match &self.

pub fn match_mut<StabbyOut, ResolvedFn, EmptyFn, PendingFn, 'st_lt>( &'st_lt mut self, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(&mut T) -> StabbyOut, EmptyFn: FnOnce() -> StabbyOut, PendingFn: FnOnce(&mut F) -> StabbyOut,

Equivalent to match &mut self.

pub fn match_owned_ctx<StabbyOut, StabbyCtx, ResolvedFn, EmptyFn, PendingFn>( self, stabby_ctx: StabbyCtx, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(StabbyCtx, T) -> StabbyOut, EmptyFn: FnOnce(StabbyCtx) -> StabbyOut, PendingFn: FnOnce(StabbyCtx, F) -> StabbyOut,

Equivalent to match self, but allows you to pass common arguments to all closures to make the borrow checker happy.

pub fn match_ref_ctx<'st_lt, StabbyCtx, StabbyOut, ResolvedFn, EmptyFn, PendingFn>( &'st_lt self, stabby_ctx: StabbyCtx, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(StabbyCtx, &'st_lt T) -> StabbyOut, EmptyFn: FnOnce(StabbyCtx) -> StabbyOut, PendingFn: FnOnce(StabbyCtx, &'st_lt F) -> StabbyOut,

Equivalent to match &self, but allows you to pass common arguments to all closures to make the borrow checker happy.

pub fn match_mut_ctx<StabbyCtx, StabbyOut, ResolvedFn, EmptyFn, PendingFn, 'st_lt>( &'st_lt mut self, stabby_ctx: StabbyCtx, Resolved: ResolvedFn, Empty: EmptyFn, Pending: PendingFn, ) -> StabbyOut

where ResolvedFn: FnOnce(StabbyCtx, &mut T) -> StabbyOut, EmptyFn: FnOnce(StabbyCtx) -> StabbyOut, PendingFn: FnOnce(StabbyCtx, &mut F) -> StabbyOut,

Equivalent to match &mut self, but allows you to pass common arguments to all closures to make the borrow checker happy.

Trait Implementations

impl<T, F> Future for MaybeResolved<T, F>

where T: IStable + Unpin + IDeterminantProvider<Result<(), F>>, F: IStable + Future<Output = T> + Unpin, Result<(), F>: IStable, (): IDeterminantProvider<F>,

type Output = T

The type of value produced on completion.

fn poll( self: Pin<&mut MaybeResolved<T, F>>, cx: &mut Context<'_>, ) -> Poll<<MaybeResolved<T, F> as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T, F> IStable for MaybeResolved<T, F>

where F: IStable + Future<Output = T>, (): IStable + IDeterminantProvider<F>, T: IStable + IDeterminantProvider<Result<(), F>>, Result<(), F>: IStable, Result<T, Result<(), F>>: IStable,

const REPORT: &'static TypeReport

A compile-time generated report of the fields of the type, allowing for compatibility inspection.

const ID: u64

A stable (and ideally unique) identifier for the type. Often generated using crate::report::gen_id, but can be manually set.

type ForbiddenValues = <Result<T, Result<(), F>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Result<T, Result<(), F>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Result<T, Result<(), F>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Result<T, Result<(), F>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = B0

Allows the detection of whether or not core::option::Options are stable:

type ContainsIndirections = <Result<T, Result<(), F>> as IStable>::ContainsIndirections

Whether or not the type contains indirections (pointers, indices in independent data-structures…)

type CType = <Result<T, Result<(), F>> as IStable>::CType

A support mechanism for safer-ffi, allowing all IStable types to also be safer_ffi::ReprC

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

unsafe fn is_invalid(ptr: *const u8) -> bool

Returns true if ptr points to memory that cannot be a valid value of Self.