Crate std

The Redox Library

The Redox Library contains a collection of commonly used low-level software constructs to be used on top of the base operating system, including graphics support and windowing, a basic filesystem, audio support, a simple console with shell style functions, an event system, and environment argument support.

Reexports

extern crate core as core;

extern crate core as __core;

extern crate collections as core_collections;

extern crate rand as core_rand;

extern crate alloc;

extern crate rustc_unicode;

extern crate system;

use core::prelude::v1::*;

pub use rand_old::*;

Modules

alloc_system
any	This module implements the Any trait, which enables dynamic typing of any 'static type through runtime reflection.
arc	Threadsafe reference-counted boxes (the Arc<T> type).
ascii	Operations on ASCII strings and characters
borrow	A module for working with borrowed data.
boxed	A pointer type for heap allocation.
cell	Shareable mutable containers.
char	A character type.
clone	The Clone trait for types that cannot be 'implicitly copied'
cmp	Functionality for ordering and comparison.
collections	Collection types.
convert	Traits for conversions between types.
default	The Default trait for types which may have meaningful default values.
env	Enviroment data
error	Traits for working with Errors.
fmt	Utilities for formatting and printing strings
fs
get_slice
hash	Generic hashing support.
i16	The 16-bit signed integer type.
i32	The 32-bit signed integer type.
i64	The 64-bit signed integer type.
i8	The 8-bit signed integer type.
io	IO
isize	The pointer-sized signed integer type.
iter	Composable external iteration
macros	Standard library macros
marker	Primitive traits and marker types representing basic 'kinds' of types.
mem	Basic functions for dealing with memory
net	A module dealing with network connections
num	Numeric traits and functions for the built-in numeric types.
ops	Overloadable operators
option	Optional values
panic
ptr	Raw, unsafe pointers, *const T, and *mut T
rc	Thread-local reference-counted boxes (the Rc<T> type).
result	Error handling with the Result type
slice	A dynamically-sized view into a contiguous sequence, [T].
str	Unicode string slices
string	A UTF-8 encoded, growable string.
to_num	Types convertable to integers
u16	The 16-bit unsigned integer type.
u32	The 32-bit unsigned integer type.
u64	The 64-bit unsigned integer type.
u8	The 8-bit unsigned integer type.
url
usize	The pointer-sized unsigned integer type.
vec	A growable list type with heap-allocated contents, written Vec<T> but pronounced 'vector.'
intrinsics	[Unstable] rustc compiler intrinsics.
panicking	[Unstable] Panic support for libcore
path
prelude	The Rust Prelude
process
rand	[Unstable]
rand_old
raw	[Unstable] Contains struct definitions for the layout of compiler built-in types.
rt
sync
thread
time	A module for time

Macros

assert!	Ensure that a boolean expression is true at runtime.
assert_eq!	Asserts that two expressions are equal to each other.
debug_assert!	Ensure that a boolean expression is true at runtime.
debug_assert_eq!	Asserts that two expressions are equal to each other.
format!	Use the syntax described in std::fmt to create a value of type String. See std::fmt for more information.
panic!	The entry point for panic of Rust threads.
print!	Macro for printing to the standard output.
println!	Macro for printing to the standard output, with a newline.
select!	A macro to select an event from a number of receivers.
try!	Helper macro for unwrapping Result values while returning early with an error if the value of the expression is Err. Can only be used in functions that return Result because of the early return of Err that it provides.
unimplemented!	A standardized placeholder for marking unfinished code. It panics with the message "not yet implemented" when executed.
unreachable!	A utility macro for indicating unreachable code.
vec!	Creates a Vec containing the arguments.
write!	Use the format! syntax to write data into a buffer.
writeln!	Use the format! syntax to write data into a buffer, appending a newline.