A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
Reference Counted’.
An integer type which can be safely shared between threads.
An owning iterator over the entries of a BTreeMap.
An iterator over the entries of a BTreeMap.
A mutable iterator over the entries of a BTreeMap.
An iterator over the keys of a BTreeMap.
An ordered map based on a
B-Tree.
An ordered set based on a B-Tree.
An iterator over the values of a BTreeMap.
A priority queue implemented with a binary heap.
A mutable memory location.
An iterator over the
chars of a string slice.
A Condition Variable
An owned permission to join on a thread (block on its termination).
A mutual exclusion primitive useful for protecting shared data
A type that can represent owned, mutable platform-native strings, but is
cheaply inter-convertible with Rust strings.
An error which can be returned when parsing an integer.
A slice of a path (akin to
str).
An iterator with a peek() that returns an optional reference to the next
element.
Zero-sized type used to mark things that “act like” they own a T.
RandomState is the default state for
HashMap types.
A (half-open) range bounded inclusively below and exclusively above
(start..end).
A range bounded inclusively below and above (start..=end).
A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference
Counted’.
Weak is a version of
Rc that holds a non-owning reference to the
managed allocation. The allocation is accessed by calling
upgrade on the
Weak
pointer, which returns an
Option<Rc<T>>.
A mutable memory location with dynamically checked borrow rules
Immutable slice iterator
Mutable slice iterator.
A double-ended queue implemented with a growable ring buffer.
An iterator that moves out of a vector.
The addition operator +.
The addition assignment operator +=.
The bitwise AND operator &.
The bitwise AND assignment operator &=.
The bitwise OR operator |.
The bitwise OR assignment operator |=.
A trait for borrowing data.
A trait for mutably borrowing data.
A trait for creating instances of
Hasher.
? formatting.
Used for immutable dereferencing operations, like *v.
Used for mutable dereferencing operations, like in *v = 1;.
Format trait for an empty format, {}.
The division operator /.
Error is a trait representing the basic expectations for error values,
i.e., values of type
E in
Result<T, E>.
Parse a value from a string
An iterator that always continues to yield None when exhausted.
A hashable type.
A trait for hashing an arbitrary stream of bytes.
Used for indexing operations (container[index]) in immutable contexts.
Used for indexing operations (container[index]) in mutable contexts.
The multiplication operator *.
The unary negation operator -.
RangeBounds is implemented by Rust’s built-in range types, produced
by range syntax like .., a.., ..b, ..=c, d..e, or f..=g.
The remainder operator %.
The left shift operator <<. Note that because this trait is implemented
for all integer types with multiple right-hand-side types, Rust’s type
checker has special handling for _ << _, setting the result type for
integer operations to the type of the left-hand-side operand. This means
that though a << b and a.shl(b) are one and the same from an evaluation
standpoint, they are different when it comes to type inference.
The left shift assignment operator <<=.
The right shift operator >>. Note that because this trait is implemented
for all integer types with multiple right-hand-side types, Rust’s type
checker has special handling for _ >> _, setting the result type for
integer operations to the type of the left-hand-side operand. This means
that though a >> b and a.shr(b) are one and the same from an evaluation
standpoint, they are different when it comes to type inference.
The right shift assignment operator >>=.
The subtraction operator -.