#[repr(C)]pub struct Result {
pub mImpl: Result_Impl,
}
Expand description
Result<V, E> represents the outcome of an operation that can either succeed or fail. It contains either a success value of type V or an error value of type E.
All Result methods are const, so results are basically immutable. This is just like Variant<V, E> but with a slightly different API, and the following cases are optimized so Result can be stored more efficiently:
-
If both the success and error types do not use their least significant bit, are trivially copyable and destructible, Result<V, E> is guaranteed to be as large as the larger type. This is determined via the HasFreeLSB trait. By default, empty classes (in particular Ok) and aligned pointer types are assumed to have a free LSB, but you can specialize this trait for other types. If the success type is empty, the representation is guaranteed to be all zero bits on success. Do not change this representation! There is JIT code that depends on it. (Implementation note: The lowest bit is used as a tag bit: 0 to indicate the Result’s bits are a success value, 1 to indicate the Result’s bits (with the 1 masked out) encode an error value)
-
Else, if the error type can’t have a all-zero bits representation and is not larger than a pointer, a CompactPair is used to represent this rather than a Variant. This has shown to be better optimizable, and the template code is much simpler than that of Variant, so it should also compile faster. Whether an error type can’t be all-zero bits, is determined via the UnusedZero trait. MFBT doesn’t declare any public type UnusedZero, but nsresult is declared UnusedZero in XPCOM.
The purpose of Result is to reduce the screwups caused by using false
or
nullptr
to indicate errors.
What screwups? See https://bugzilla.mozilla.org/show_bug.cgi?id=912928 for
a partial list.
Result<const V, E> or Result<V, const E> are not meaningful. The success or error values in a Result instance are non-modifiable in-place anyway. This guarantee must also be maintained when evolving Result. They can be unwrap()ped, but this loses const qualification. However, Result<const V, E> or Result<V, const E> may be misleading and prevent movability. Just use Result<V, E>. (Result<const V*, E> may make sense though, just Result<const V* const, E> is not possible.)
Fields§
§mImpl: Result_Impl
Trait Implementations§
impl Copy for Result
impl StructuralPartialEq for Result
Auto Trait Implementations§
impl Freeze for Result
impl RefUnwindSafe for Result
impl Send for Result
impl Sync for Result
impl Unpin for Result
impl UnwindSafe for Result
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more