Crate std_prelude

Expand description

use std_prelude::* so you can be ready to code!

§Traits

Not having common traits imported is one of the most annoying gotchas in rust when coming from other languages. When you are used to the language, you expect the commonly used methods to always work… not so in rust! Using Vec::from_iter is extremely common, but you must first import the FromIterator trait.

The following are the traits that are exported and why:

std::ascii::AsciiExt: adds the to_ascii_uppercase onto &str types.
std::borrow::Borrow: for manually defining the Borrow trait.
std::cmp::{Ord, PartialOrd}: for manually defining the Ordering traits and using them in trait bounds.
std::fmt::Debug: allows you to define Debug manually and use in trait bounds.
std::hash::{Hash, Hasher}: allows you to define Hash manually and use in trait bounds.
std::fmt::Write as FmtWrite: adds write_str onto byte buffers (such as String). Renamed FmtWrite to avoid conflict with std::io::Write
std::io::BufRead: the BufRead trait allows you to use the methods associated with the BufReader struct (also imported).
std::io::Read: allows you to use file.read()
std::io::Seek: allows you to use file.seek()
std::io::Write as IoWrite: allows you to use file.write() and file.write_all(). Renamed IoWrite to avoid conflict with std::fmt::Write
std::ops::{Deref, DerefMut}: allows deref through *v and also enables Deref coercions
std::str::FromStr: allows you to use type::from_str constructor for several types. This is what is implicitly called with str::parse<_>()

§Structs

These are extremely commonly used types and it is annoying to have to reimport them all the time.

std::borrow::Cow: A clone-on-write smart pointer (often called copy on write in other languages). This is used by many libraries to be as efficient as possible when returned data is identical to the data passed in, among other uses.
std::collections::{BTreeMap, HashMap, HashSet}: ordered-dict, dict and set
std::cmp::Ordering: the enum type used in the Ordering traits.
std::ffi::OsString: os agnostic (non unicode) string type. std::path::PathBuf uses this.
std::fs::File: for opening files.
- File::open to open a file for reading
- File::write to open a file for writing
std::fs::OpenOptions: file opening options.
std::fs::ReadDir: to iterate over the entries in a directory.
std::io::BufReader: the BufRead struct wraps io::Read using a buffer reducing the number of OS calls and giving helpful methods
- read_line(): read a single line
- lines(): return an iterator over all lines.
- split(byte: u8): return an iterator which splits at the chosen byte.
std::io::BufWriter: similar to BufReader, buffers writes to reduce the number of calls to the OS. Provides no new methods.
std::path::{Path, PathBuf}: specifies an os path.
std::rc::Rc: reference counted pointer
std::sync::Arc: atomically reference counted pointer
std::sync::Mutex: mutual exclusion primitive for threading.
std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize}: basic atomic types. Good for unique ids and lots of other use cases.
std::sync::atomic::Ordering as AtomicOrdering: necessary for performing operations on atomic types. For incrementing a counter use val.fetch_add(1, AtomicOrdering::SeqCst). Renamed to not conflict with std::cmp::Ordering.
std::sync::atomic::ATOMIC_USIZE_INIT: initialized AtomicUsize of 0. Use with static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
std::time::Duration: an amount of time, used for std::thread::sleep.

§Functions

These are mostly just “nice to have” functions and it is really unlikely that they would ever be overriden.

std::cmp::{max, min}: get the max or min of two comparable integers.
std::mem::{size_of, size_of_val}: get the size of a type. This is safe and common enough that it should be always available.
std::thread::sleep: put the thread to sleep for a Duration.
std::thread::spawn: spawn a function in a new thread. In rust this is memory safe, so it is nice to have it always available.

§Modules (primitive type only)

The following modules are imported so that it is easy to access their relevant constants and constructors.

u8 u16 u64 usize: unsigned integer modules with MAX and MIN
i8 i16 i64 isize: signed integer modules with MAX and MIN
f32 f64: floating point modules with not just MAX and MIN but also NAN, INFINITY, etc as well as a f32::consts and f64::consts modules with basic mathematical constants like PI and E.
str: core string type with from_utf8 function.

Modules§

f32: Constants for the f32 single-precision floating point type.
f64: Constants for the f64 double-precision floating point type.
i8Deprecation planned: Redundant constants module for the i8 primitive type.
i16Deprecation planned: Redundant constants module for the i16 primitive type.
i64Deprecation planned: Redundant constants module for the i64 primitive type.
isizeDeprecation planned: Redundant constants module for the isize primitive type.
str: Utilities for the str primitive type.
u8Deprecation planned: Redundant constants module for the u8 primitive type.
u16Deprecation planned: Redundant constants module for the u16 primitive type.
u64Deprecation planned: Redundant constants module for the u64 primitive type.
usizeDeprecation planned: Redundant constants module for the usize primitive type.

Structs§

Arc: A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.
AtomicBool: A boolean type which can be safely shared between threads.
AtomicIsize: An integer type which can be safely shared between threads.
AtomicUsize: An integer type which can be safely shared between threads.
BTreeMap: An ordered map based on a B-Tree.
BufReader: The BufReader<R> struct adds buffering to any reader.
BufWriter: Wraps a writer and buffers its output.
Duration: A Duration type to represent a span of time, typically used for system timeouts.
File: An object providing access to an open file on the filesystem.
HashMap: A hash map implemented with quadratic probing and SIMD lookup.
HashSet: A hash set implemented as a HashMap where the value is ().
Mutex: A mutual exclusion primitive useful for protecting shared data
OpenOptions: Options and flags which can be used to configure how a file is opened.
OsString: A type that can represent owned, mutable platform-native strings, but is cheaply inter-convertible with Rust strings.
Path: A slice of a path (akin to str).
PathBuf: An owned, mutable path (akin to String).
Rc: A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference Counted’.
ReadDir: Iterator over the entries in a directory.

Enums§

AtomicOrdering: Atomic memory orderings
Cow: A clone-on-write smart pointer.
Ordering: An Ordering is the result of a comparison between two values.
SeekFrom: Enumeration of possible methods to seek within an I/O object.

Constants§

ATOMIC_USIZE_INITDeprecated: An AtomicUsize initialized to 0.

Traits§

AsciiExtDeprecated: Extension methods for ASCII-subset only operations.
Borrow: A trait for borrowing data.
BufRead: A BufRead is a type of Reader which has an internal buffer, allowing it to perform extra ways of reading.
Debug: ? formatting.
Deref: Used for immutable dereferencing operations, like *v.
DerefMut: Used for mutable dereferencing operations, like in *v = 1;.
FmtWrite: A trait for writing or formatting into Unicode-accepting buffers or streams.
FromIterator: Conversion from an Iterator.
FromStr: Parse a value from a string
Hash: A hashable type.
Hasher: A trait for hashing an arbitrary stream of bytes.
IoWrite: A trait for objects which are byte-oriented sinks.
Ord: Trait for types that form a total order.
PartialOrd: Trait for types that form a partial order.
Read: The Read trait allows for reading bytes from a source.
Seek: The Seek trait provides a cursor which can be moved within a stream of bytes.

Functions§

size_of: Returns the size of a type in bytes.
size_of_val: Returns the size of the pointed-to value in bytes.
sleep: Puts the current thread to sleep for at least the specified amount of time.
spawn: Spawns a new thread, returning a JoinHandle for it.

Derive Macros§

Debug: Derive macro generating an impl of the trait Debug.
Hash: Derive macro generating an impl of the trait Hash.
Ord: Derive macro generating an impl of the trait Ord. 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.

Crate std_preludeCopy item path