Commonly Used Library Types

The Sway Standard Library is the foundation of portable Sway software, a set of minimal shared abstractions for the broader Sway ecosystem. It offers core types, library-defined operations on language primitives, native asset management, blockchain contextual operations, access control, storage management, and support for types from other VMs, among many other things. Reference the standard library docs here.

Result<T, E>

Type Result is the type used for returning and propagating errors. It is an enum with two variants: Ok(T), representing success and containing a value, and Err(E), representing error and containing an error value. The T and E in this definition are type parameters, allowing Result to be generic and to be used with any types.

/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
pub enum Result<T, E> {
    /// Contains the success value.
    Ok: T,
    /// Contains the error value.
    Err: E,
}

Functions return Result whenever errors are expected and recoverable. Take the following example:

script;

enum MyContractError {
    DivisionByZero: (),
}

fn divide(numerator: u64, denominator: u64) -> Result<u64, MyContractError> {
    if (denominator == 0) {
        return Result::Err(MyContractError::DivisionByZero);
    } else {
        Result::Ok(numerator / denominator)
    }
}

fn main() -> Result<u64, str[4]> {
    let result = divide(20, 2);
    match result {
        Result::Ok(value) => Result::Ok(value),
        Result::Err(MyContractError::DivisionByZero) => Result::Err("Fail"),
    }
}

Option<T>

Type Option represents an optional value: every Option is either Some and contains a value, or None, and does not. Option types are very common in Sway code, as they have a number of uses:

• Initial values where None can be used as an initializer.
• Return value for otherwise reporting simple errors, where None is returned on error.

The implementation of Option matches on the variant: if it's Ok it returns the inner value, if it's None, it reverts.

/// A type that represents an optional value, either `Some(val)` or `None`.
pub enum Option<T> {
    /// No value.
    None: (),
    /// Some value of type `T`.
    Some: T,
}

Option is commonly paired with pattern matching to query the presence of a value and take action, allowing developers to choose how to handle the None case.

Below is an example that uses pattern matching to handle invalid divisions by 0 by returning an Option:

script;

fn divide(numerator: u64, denominator: u64) -> Option<u64> {
    if denominator == 0 {
        Option::None
    } else {
        Option::Some(numerator / denominator)
    }
}

fn main() {
    let result = divide(6, 2);
    // Pattern match to retrieve the value
    match result {
        // The division was valid
        Option::Some(x) => std::logging::log(x),
        // The division was invalid
        Option::None => std::logging::log("Cannot divide by 0"),
    }
}