std, primitives and preludes

⭐️ In Rust, language elements are implemented by not only std library crate but also compiler as well. Examples,

• Primitives : Defined by the compiler and methods are implemented by std library directly on primitives.

• Standard Macros : Defined by both compiler and std

std library has been has divided into modules, according to the main areas each covered.

⭐️ While primitives are implemented by the compiler, the standard library implements most useful methods directly on the primitive types. But some rarely useful language elements of some primitives are stored on relevant std modules. This is why you can see char, str and integer types on both primitives and std modules.

Primitives

// Primitives : Defined by the compiler and methods are directly implemented by std
bool, char, slice, str

i8, i16, i32, i64, i128, isize // i128 : nightly-only experimental API
u8, u16, u32, u64, u128, usize // u128 : nightly-only experimental API

f32, f64

array, tuple

pointer, fn, reference

Standard Macros

// Standard Macros also defined by both compiler and std
print, println, eprint, eprintln
format, format_args
write, writeln

concat, concat_idents, stringify //concat_idents : nightly-only experimental API

include, include_bytes, include_str

assert, assert_eq, assert_ne
debug_assert, debug_assert_eq, debug_assert_ne

try, panic, compile_error, unreachable, unimplemented

file, line, column, module_path
env, option_env
cfg

select, thread_local //select : nightly-only experimental API

vec

Std Modules

// std modules
char, str

i8, i16, i32, i64, i128, isize // i128 : nightly-only experimental API
u8, u16, u32 ,u64, u128, usize // u128 : nightly-only experimental API
f32, f64
num

vec, slice, hash, heap, collections // heap : nightly-only experimental API

string, ascii, fmt

default

marker, clone, convert, cmp, iter

ops, ffi

option, result, panic, error

io
fs, path
mem, thread, sync
process, env
net
time
os

ptr, boxed, borrow, cell, any, rc

prelude

intrinsics // intrinsics : nightly-only experimental API
raw // raw : nightly-only experimental API

🔎 When examine Rust’s source code, you can see that src directory is a workspace. Even though its having many library crates, by examine root Cargo.toml file you can easily identify that main crates are rustc(compiler) and libstd (std). In libstd/lib.rs std modules have been re-exported via pub use and the original location of most of std modules is src/libcore.

Few important std modules are,

• std::io - Core I/O functionality

• std::fs - Filesystem specific functionality

• std::path - Cross platform path specific functionality

• std::env - Process’s environment related functionality

• std::mem - Memory related functionality

• std::net - TCP/UDP communication

• std::os - OS specific functionality

• std::thread - Native threads specific functionality

• std::collections - Core Collection types

💯 Refer Rust Standard Library Documentation for more details.

Preludes

Even though Rust std contains many modules, by default it doesn’t load each and every thing of std library on every rust program. Instead, it loads only the smallest list of things which require for almost every single Rust program. These are called preludes. They import only,

// Reexported core operators
pub use marker::{Copy, Send, Sized, Sync};
pub use ops::{Drop, Fn, FnMut, FnOnce};

// Reexported functions
pub use mem::drop;

// Reexported types and traits
pub use boxed::Box;
pub use borrow::ToOwned;
pub use clone::Clone;
pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
pub use convert::{AsRef, AsMut, Into, From};
pub use default::Default;
pub use iter::{Iterator, Extend, IntoIterator};
pub use iter::{DoubleEndedIterator, ExactSizeIterator};
pub use option::Option::{self, Some, None};
pub use result::Result::{self, Ok, Err};
pub use slice::SliceConcatExt;
pub use string::{String, ToString};
pub use vec::Vec;

Preludes have been imported explicitly on libstd/lib.rs and the whole list can be seen on libstd/prelude/v1.rs.

⭐️ So technically, Rust inserts,

• extern crate std; : into the crate root of every crate

• use std::prelude::v1::*; : into every module

  So you don’t need to import these each time.

The concept of preludes is quite common on Rust libraries. Even some modules inside std crate (ex.libstd/io) and many libraries (ex. diesel) are having their own prelude modules.

⭐️ But preludes are used to create a single place to import all important components which are required while using the library. They do not load automatically unless you imported them manually. Only std::prelude imports automatically in every Rust programs.