Module prelude

The gstd default prelude. Re-imports default std modules and traits. std can be safely replaced to gstd in the Rust programs.

Re-exports

pub use crate::ReservationIdExt;

pub use parity_scale_codec as codec;

pub use scale_info;

Modules

any

Utilities for dynamic typing or type reflection.

array

Utilities for the array primitive type.

ascii

Operations on ASCII strings and characters.

borrow

A module for working with borrowed data.

boxed

The Box<T> type for heap allocation.

cell

Shareable mutable containers.

char

Utilities for the char primitive type.

clone

The Clone trait for types that cannot be ‘implicitly copied’.

cmp

Utilities for comparing and ordering values.

collections

Collection types.

convert

Traits for conversions between types.

default

The Default trait for types with a default value.

ffi

Utilities related to FFI bindings.

fmt

Utilities for formatting and printing Strings.

future

Asynchronous basic functionality.

hash

Generic hashing support.

hint

Hints to compiler that affects how code should be emitted or optimized.

iter

Composable external iteration.

marker

Primitive traits and types representing basic properties of types.

mem

Basic functions for dealing with memory.

num

Numeric traits and functions for the built-in numeric types.

ops

Overloadable operators.

option

Optional values.

panic

Panic support in the standard library.

pin

Types that pin data to a location in memory.

primitive

This module reexports the primitive types to allow usage that is not possibly shadowed by other declared types.

ptr

Manually manage memory through raw pointers.

rc

Single-threaded reference-counting pointers. ‘Rc’ stands for ‘Reference Counted’.

result

Error handling with the Result type.

slice

Slice management and manipulation.

str

Utilities for the str primitive type.

string

A UTF-8–encoded, growable string.

task

Types and Traits for working with asynchronous tasks.

time

Temporal quantification.

vec

A contiguous growable array type with heap-allocated contents, written Vec<T>.

Macros

assert

Asserts that a boolean expression is true at runtime.

assert_eq

Asserts that two expressions are equal to each other (using PartialEq).

assert_ne

Asserts that two expressions are not equal to each other (using PartialEq).

cfg

Evaluates boolean combinations of configuration flags at compile-time.

column

Expands to the column number at which it was invoked.

compile_error

Causes compilation to fail with the given error message when encountered.

concat

Concatenates literals into a static string slice.

dbg

Prints and returns the value of a given expression for quick and dirty debugging.

debug_assert

Asserts that a boolean expression is true at runtime.

debug_assert_eq

Asserts that two expressions are equal to each other.

debug_assert_ne

Asserts that two expressions are not equal to each other.

env

Inspects an environment variable at compile time.

file

Expands to the file name in which it was invoked.

format

Creates a String using interpolation of runtime expressions.

format_args

Constructs parameters for the other string-formatting macros.

include

Parses a file as an expression or an item according to the context.

include_bytes

Includes a file as a reference to a byte array.

include_str

Includes a UTF-8 encoded file as a string.

line

Expands to the line number on which it was invoked.

matches

Returns whether the given expression matches the provided pattern.

module_path

Expands to a string that represents the current module path.

option_env

Optionally inspects an environment variable at compile time.

panic

Panics the current thread.

static_mut

Get mutable reference to static mut.

static_ref

Get shared reference to static mut.

stringify

Stringifies its arguments.

todo

Indicates unfinished code.

unimplemented

Indicates unimplemented code by panicking with a message of “not implemented”.

unreachable

Indicates unreachable code.

vec

Creates a Vec containing the arguments.

write

Writes formatted data into a buffer.

writeln

Writes formatted data into a buffer, with a newline appended.

concat_bytesExperimental

Concatenates literals into a byte slice.

concat_identsExperimental

Concatenates identifiers into one identifier.

derefExperimental

Unstable placeholder for deref patterns.

format_args_nlExperimental

Same as format_args, but adds a newline in the end.

log_syntaxExperimental

Prints passed tokens into the standard output.

trace_macrosExperimental

Enables or disables tracing functionality used for debugging other macros.

type_ascribeExperimental

Unstable placeholder for type ascription.

Structs

Box

A pointer type that uniquely owns a heap allocation of type T.

String

A UTF-8–encoded, growable string.

Vec

A contiguous growable array type, written as Vec<T>, short for ‘vector’.

Enums

Option

The Option type. See the module level documentation for more.

Result

Result is a type that represents either success (Ok) or failure (Err).

Traits

AsMut

Used to do a cheap mutable-to-mutable reference conversion.

AsRef

Used to do a cheap reference-to-reference conversion.

AsyncFn

An async-aware version of the Fn trait.

AsyncFnMut

An async-aware version of the FnMut trait.

AsyncFnOnce

An async-aware version of the FnOnce trait.

Clone

A common trait for the ability to explicitly duplicate an object.

Copy

Types whose values can be duplicated simply by copying bits.

Decode

Trait that allows zero-copy read of value-references from slices in LE format.

Default

A trait for giving a type a useful default value.

DoubleEndedIterator

An iterator able to yield elements from both ends.

Drop

Custom code within the destructor.

Encode

Trait that allows zero-copy write of value-references to slices in LE format.

EncodeLike

A marker trait that tells the compiler that a type encode to the same representation as another type.

Eq

Trait for comparisons corresponding to equivalence relations.

ExactSizeIterator

An iterator that knows its exact length.

Extend

Extend a collection with the contents of an iterator.

Fn

The version of the call operator that takes an immutable receiver.

FnMut

The version of the call operator that takes a mutable receiver.

FnOnce

The version of the call operator that takes a by-value receiver.

From

Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.

FromIterator

Conversion from an Iterator.

Into

A value-to-value conversion that consumes the input value. The opposite of From.

IntoIterator

Conversion into an Iterator.

Iterator

A trait for dealing with iterators.

MaxEncodedLen

Items implementing MaxEncodedLen have a statically known maximum encoded size.

Ord

Trait for types that form a total order.

PartialEq

Trait for comparisons using the equality operator.

PartialOrd

Trait for types that form a partial order.

Send

Types that can be transferred across thread boundaries.

Sized

Types with a constant size known at compile time.

Sync

Types for which it is safe to share references between threads.

ToOwned

A generalization of Clone to borrowed data.

ToString

A trait for converting a value to a String.

TryFrom

Simple and safe type conversions that may fail in a controlled way under some circumstances. It is the reciprocal of TryInto.

TryInto

An attempted conversion that consumes self, which may or may not be expensive.

TypeInfo

Implementors return their meta type information.

Unpin

Types that do not require any pinning guarantees.

Functions

align_of

Returns the ABI-required minimum alignment of a type in bytes.

align_of_val

Returns the ABI-required minimum alignment of the type of the value that val points to in bytes.

drop

Disposes of a value.

size_of

Returns the size of a type in bytes.

size_of_val

Returns the size of the pointed-to value in bytes.

Attribute Macros

derive

Attribute macro used to apply derive macros.

global_allocator

Attribute macro applied to a static to register it as a global allocator.

test

Attribute macro applied to a function to turn it into a unit test.

alloc_error_handlerExperimental

Attribute macro applied to a function to register it as a handler for allocation failure.

benchExperimental

Attribute macro applied to a function to turn it into a benchmark test.

cfg_accessibleExperimental

Keeps the item it’s applied to if the passed path is accessible, and removes it otherwise.

cfg_evalExperimental

Expands all #[cfg] and #[cfg_attr] attributes in the code fragment it’s applied to.

define_opaqueExperimental

Provide a list of type aliases and other opaque-type-containing type definitions. This list will be used in the body of the item it is applied to define opaque types’ hidden types. Can only be applied to things that have bodies.

derive_constExperimental

Attribute macro used to apply derive macros for implementing traits in a const context.

test_caseExperimental

An implementation detail of the #[test] and #[bench] macros.

Derive Macros

Clone

Derive macro generating an impl of the trait Clone.

Copy

Derive macro generating an impl of the trait Copy.

Debug

Derive macro generating an impl of the trait Debug.

Decode

Derive parity_scale_codec::Decode for struct and enum.

Default

Derive macro generating an impl of the trait Default.

Encode

Derive parity_scale_codec::Encode and parity_scale_codec::EncodeLike for struct and enum.

Eq

Derive macro generating an impl of the trait Eq.

Hash

Derive macro generating an impl of the trait Hash.

MaxEncodedLen

Derive parity_scale_codec::MaxEncodedLen for struct and enum.

Ord

Derive macro generating an impl of the trait Ord. The behavior of this macro is described in detail here.

PartialEq

Derive macro generating an impl of the trait PartialEq. The behavior of this macro is described in detail here.

PartialOrd

Derive macro generating an impl of the trait PartialOrd. The behavior of this macro is described in detail here.

TypeInfo