Skip to main content

Module std::option

This module defines the Option type and its methods to represent and handle an optional value.

use std::vector;

Struct Option​

Abstraction of a value that may or may not be present. Implemented with a vector of size zero or one because Move bytecode does not have ADTs.

public struct Option<Element> has copy, drop, store
Click to open
Fields
vec: vector<Element>

Constants​

The Option is in an invalid state for the operation attempted.
The Option is Some while it should be None.

const EOPTION_IS_SET: u64 = 262144;

The Option is in an invalid state for the operation attempted.
The Option is None while it should be Some.

const EOPTION_NOT_SET: u64 = 262145;

Function none​

Return an empty Option

public fun none<Element>(): std::option::Option<Element>

Function some​

Return an Option containing e

public fun some<Element>(e: Element): std::option::Option<Element>

Function is_none​

Return true if t does not hold a value

public fun is_none<Element>(t: &std::option::Option<Element>): bool

Function is_some​

Return true if t holds a value

public fun is_some<Element>(t: &std::option::Option<Element>): bool

Function contains​

Return true if the value in t is equal to e_ref.
Always returns false if t does not hold a value

public fun contains<Element>(t: &std::option::Option<Element>, e_ref: &Element): bool

Function borrow​

Return an immutable reference to the value inside t.
Aborts if t does not hold a value

public fun borrow<Element>(t: &std::option::Option<Element>): &Element

Function borrow_with_default​

Return a reference to the value inside t if it holds one.
Return default_ref if t does not hold a value

public fun borrow_with_default<Element>(t: &std::option::Option<Element>, default_ref: &Element): &Element

Function get_with_default​

Return the value inside t if it holds one.
Return default if t does not hold a value

public fun get_with_default<Element: copy, drop>(t: &std::option::Option<Element>, default: Element): Element

Function fill​

Convert the none option t to a some option by adding e.
Aborts if t already holds a value

public fun fill<Element>(t: &mut std::option::Option<Element>, e: Element)

Function extract​

Convert a some option to a none by removing and returning the value stored inside t.
Aborts if t does not hold a value

public fun extract<Element>(t: &mut std::option::Option<Element>): Element

Function borrow_mut​

Return a mutable reference to the value inside t.
Aborts if t does not hold a value

public fun borrow_mut<Element>(t: &mut std::option::Option<Element>): &mut Element

Function swap​

Swap the old value inside t with e and return the old value.
Aborts if t does not hold a value

public fun swap<Element>(t: &mut std::option::Option<Element>, e: Element): Element

Function swap_or_fill​

Swap the old value inside t with e and return the old value; or if there is no old value, fill it with e.
Different from swap(), swap_or_fill() allows for t not holding a value.

public fun swap_or_fill<Element>(t: &mut std::option::Option<Element>, e: Element): std::option::Option<Element>

Function destroy_with_default​

Destroys t. If t holds a value, return it. Returns default otherwise

public fun destroy_with_default<Element: drop>(t: std::option::Option<Element>, default: Element): Element

Function destroy_some​

Unpack t and return its contents.
Aborts if t does not hold a value

public fun destroy_some<Element>(t: std::option::Option<Element>): Element

Function destroy_none​

Unpack t.
Aborts if t holds a value

public fun destroy_none<Element>(t: std::option::Option<Element>)

Function to_vec​

Convert t into a vector of length 1 if it is Some, and an empty vector otherwise

public fun to_vec<Element>(t: std::option::Option<Element>): vector<Element>

Macro function destroy​

Destroy Option<T> and call the closure f on the value inside if it holds one.

public macro fun destroy<$T, $R: drop>($o: std::option::Option<$T>, $f: |$T| -> $R)

Macro function do​

Destroy Option<T> and call the closure f on the value inside if it holds one.

public macro fun do<$T, $R: drop>($o: std::option::Option<$T>, $f: |$T| -> $R)

Macro function do_ref​

Execute a closure on the value inside t if it holds one.

public macro fun do_ref<$T, $R: drop>($o: &std::option::Option<$T>, $f: |&$T| -> $R)

Macro function do_mut​

Execute a closure on the mutable reference to the value inside t if it holds one.

public macro fun do_mut<$T, $R: drop>($o: &mut std::option::Option<$T>, $f: |&mut $T| -> $R)

Macro function or​

Select the first Some value from the two options, or None if both are None.
Equivalent to Rust's a.or(b).

public macro fun or<$T>($o: std::option::Option<$T>, $default: std::option::Option<$T>): std::option::Option<$T>

Macro function and​

If the value is Some, call the closure f on it. Otherwise, return None.
Equivalent to Rust's t.and_then(f).

public macro fun and<$T, $U>($o: std::option::Option<$T>, $f: |$T| -> std::option::Option<$U>): std::option::Option<$U>

Macro function and_ref​

If the value is Some, call the closure f on it. Otherwise, return None.
Equivalent to Rust's t.and_then(f).

public macro fun and_ref<$T, $U>($o: &std::option::Option<$T>, $f: |&$T| -> std::option::Option<$U>): std::option::Option<$U>

Macro function map​

Map an Option<T> to Option<U> by applying a function to a contained value.
Equivalent to Rust's t.map(f).

public macro fun map<$T, $U>($o: std::option::Option<$T>, $f: |$T| -> $U): std::option::Option<$U>

Macro function map_ref​

Map an Option<T> value to Option<U> by applying a function to a contained value by reference.
Original Option<T> is preserved.
Equivalent to Rust's t.map(f).

public macro fun map_ref<$T, $U>($o: &std::option::Option<$T>, $f: |&$T| -> $U): std::option::Option<$U>

Macro function filter​

Return None if the value is None, otherwise return Option<T> if the predicate f returns true.

public macro fun filter<$T: drop>($o: std::option::Option<$T>, $f: |&$T| -> bool): std::option::Option<$T>

Macro function is_some_and​

Return false if the value is None, otherwise return the result of the predicate f.

public macro fun is_some_and<$T>($o: &std::option::Option<$T>, $f: |&$T| -> bool): bool

Macro function extract_or​

Extract the value inside Option<T> if it holds one, or default otherwise.
Similar to destroy_or, but modifying the input Option via a mutable reference.

public macro fun extract_or<$T>($o: &mut std::option::Option<$T>, $default: $T): $T

Macro function destroy_or​

Destroy Option<T> and return the value inside if it holds one, or default otherwise.
Equivalent to Rust's t.unwrap_or(default).

Note: this function is a more efficient version of destroy_with_default, as it does not evaluate the default value unless necessary. The destroy_with_default function should be deprecated in favor of this function.

public macro fun destroy_or<$T>($o: std::option::Option<$T>, $default: $T): $T