Struct script::dom::bindings::import::module::jsapi::mozilla::Result

#[repr(C)]
pub struct Result {
    pub mImpl: SelectResultImpl,
}

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: SelectResultImpl

Trait Implementations

impl Clone for Result

fn clone(&self) -> Result

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Result

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq<Result> for Result

fn eq(&self, other: &Result) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Result

impl StructuralPartialEq for Result