Type Alias frame_support::dispatch::DispatchResult

pub type DispatchResult = Result<(), DispatchError>;

Unaugmented version of DispatchResultWithPostInfo that can be returned from dispatchable functions and is automatically converted to the augmented type. Should be used whenever the PostDispatchInfo does not need to be overwritten. As this should be the common case it is the implicit return type when none is specified.

Aliased Type

enum DispatchResult {
    Ok(()),
    Err(DispatchError),
}

Variants

Ok(())

Contains the success value

Err(DispatchError)

Contains the error value

Trait Implementations

impl<T, E> Decode for Result<T, E>where T: Decode, E: Decode,

fn decode<I>(input: &mut I) -> Result<Result<T, E>, Error>where I: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T, E: Debug> Defensive<T> for Result<T, E>

fn defensive_unwrap_or(self, or: T) -> T

Exactly the same as unwrap_or, but it does the defensive warnings explained in the trait docs.

fn defensive_unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T

Exactly the same as unwrap_or_else, but it does the defensive warnings explained in the trait docs.

fn defensive_unwrap_or_default(self) -> Twhere T: Default,

Exactly the same as unwrap_or_default, but it does the defensive warnings explained in the trait docs.

fn defensive(self) -> Self

Does not alter the inner value at all, but it will log warnings if the inner value is None or Err.

fn defensive_proof(self, proof: &'static str) -> Self

Same as Defensive::defensive, but it takes a proof as input, and displays it if the defensive operation has been triggered.

impl<T, E: Debug> DefensiveResult<T, E> for Result<T, E>

fn defensive_map_err<F, O: FnOnce(E) -> F>(self, o: O) -> Result<T, F>

Defensively map the error into another return type, but you are really sure that this conversion should never be needed.

fn defensive_map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>( self, default: D, f: F ) -> U

Defensively map and unpack the value to something else (U), or call the default callback if Err, which should never happen.

fn defensive_ok(self) -> Option<T>

Defensively transform this result into an option, discarding the Err variant if it happens, which should never happen.

fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E>

Exactly the same as map, but it prints the appropriate warnings if the value being mapped is Err.

impl<T, E> Encode for Result<T, E>where T: Encode, E: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<W>(&self, dest: &mut W)where W: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T, E> MaxEncodedLen for Result<T, E>where T: MaxEncodedLen, E: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PalletError, E: PalletError> PalletError for Result<T, E>

const MAX_ENCODED_SIZE: usize = _

The maximum encoded size for the implementing type.

impl<T, E> TypeInfo for Result<T, E>where T: TypeInfo + 'static, E: TypeInfo + 'static,

type Identity = Result<T, E>

The type identifying for which type info is provided.

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.