-
Notifications
You must be signed in to change notification settings - Fork 3
Commit
- Loading branch information
There are no files selected for viewing
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,347 @@ | ||
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT | ||
// file at the top-level directory of this distribution and at | ||
// http://rust-lang.org/COPYRIGHT. | ||
// | ||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | ||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | ||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | ||
// option. This file may not be copied, modified, or distributed | ||
// except according to those terms. | ||
This comment has been minimized.
Sorry, something went wrong. |
||
|
||
//! # The Rust Standard Library | ||
//! | ||
//! The Rust Standard Library provides the essential runtime | ||
//! functionality for building portable Rust software. | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
//! | ||
//! The Rust Standard Library is available to all Rust crates by | ||
//! default, just as if contained an `extern crate std` import at the | ||
//! crate root. Therefore the standard library can be accessed in | ||
//! `use` statements through the path `std`, as in `use std::thread`, | ||
//! or in expressions through the absolute path `::std`, as in | ||
//! `::std::thread::sleep_ms(100)`. | ||
//! | ||
//! Furthermore, the standard library defines [The Rust | ||
//! Prelude](prelude/index.html), a small collection of items, mostly | ||
//! traits, that are imported into and available in every module. | ||
//! | ||
//! ## What is in the standard library | ||
//! | ||
//! The standard library is a set of minimal, battle-tested | ||
//! core types and shared abstractions for the [broader Rust | ||
//! ecosystem](https://crates.io) to build on. | ||
//! | ||
//! The [primitive types](#primitives), though not defined in the | ||
//! standard library, are documented here, as are the predefined | ||
//! [macros](#macros). | ||
//! | ||
//! ## Containers and collections | ||
//! | ||
//! The [`option`](option/index.html) and | ||
//! [`result`](result/index.html) modules define optional and | ||
//! error-handling types, `Option` and `Result`. The | ||
//! [`iter`](iter/index.html) module defines Rust's iterator trait, | ||
//! [`Iterator`](iter/trait.Iterator.html), which works with the `for` | ||
//! loop to access collections. | ||
//! | ||
//! The common container type, `Vec`, a growable vector backed by an array, | ||
//! lives in the [`vec`](vec/index.html) module. Contiguous, unsized regions | ||
//! of memory, `[T]`, commonly called "slices", and their borrowed versions, | ||
//! `&[T]`, commonly called "borrowed slices", are built-in types for which the | ||
//! [`slice`](slice/index.html) module defines many methods. | ||
//! | ||
//! `&str`, a UTF-8 string, is a built-in type, and the standard library | ||
//! defines methods for it on a variety of traits in the | ||
//! [`str`](str/index.html) module. Rust strings are immutable; | ||
//! use the `String` type defined in [`string`](string/index.html) | ||
//! for a mutable string builder. | ||
//! | ||
//! For converting to strings use the [`format!`](fmt/index.html) | ||
//! macro, and for converting from strings use the | ||
//! [`FromStr`](str/trait.FromStr.html) trait. | ||
//! | ||
//! Data may be shared by placing it in a reference-counted box or the | ||
//! [`Rc`](rc/index.html) type, and if further contained in a [`Cell` | ||
//! or `RefCell`](cell/index.html), may be mutated as well as shared. | ||
//! Likewise, in a concurrent setting it is common to pair an | ||
//! atomically-reference-counted box, [`Arc`](sync/struct.Arc.html), | ||
//! with a [`Mutex`](sync/struct.Mutex.html) to get the same effect. | ||
//! | ||
//! The [`collections`](collections/index.html) module defines maps, | ||
//! sets, linked lists and other typical collection types, including | ||
//! the common [`HashMap`](collections/struct.HashMap.html). | ||
//! | ||
//! ## Platform abstractions and I/O | ||
//! | ||
//! Besides basic data types, the standard library is largely concerned | ||
//! with abstracting over differences in common platforms, most notably | ||
//! Windows and Unix derivatives. | ||
//! | ||
//! Common types of I/O, including [files](fs/struct.File.html), | ||
//! [TCP](net/struct.TcpStream.html), | ||
//! [UDP](net/struct.UdpSocket.html), are defined in the | ||
//! [`io`](io/index.html), [`fs`](fs/index.html), and | ||
//! [`net`](net/index.html) modules. | ||
//! | ||
//! The [`thread`](thread/index.html) module contains Rust's threading | ||
//! abstractions. [`sync`](sync/index.html) contains further | ||
//! primitive shared memory types, including | ||
//! [`atomic`](sync/atomic/index.html) and | ||
//! [`mpsc`](sync/mpsc/index.html), which contains the channel types | ||
//! for message passing. | ||
|
||
// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364) | ||
#![cfg_attr(stage0, feature(custom_attribute))] | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
#![crate_name = "std"] | ||
#![stable(feature = "rust1", since = "1.0.0")] | ||
#![staged_api] | ||
#![crate_type = "rlib"] | ||
#![crate_type = "dylib"] | ||
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", | ||
html_favicon_url = "https://doc.rust-lang.org/favicon.ico", | ||
html_root_url = "http://doc.rust-lang.org/nightly/", | ||
html_playground_url = "http://play.rust-lang.org/", | ||
test(no_crate_inject, attr(deny(warnings))), | ||
test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))] | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
#![feature(alloc)] | ||
#![feature(allow_internal_unstable)] | ||
#![feature(associated_consts)] | ||
#![feature(borrow_state)] | ||
#![feature(box_raw)] | ||
#![feature(box_syntax)] | ||
#![feature(char_internals)] | ||
#![feature(clone_from_slice)] | ||
#![feature(collections)] | ||
#![feature(collections_bound)] | ||
#![feature(const_fn)] | ||
#![feature(core)] | ||
#![feature(core_float)] | ||
#![feature(core_intrinsics)] | ||
#![feature(core_prelude)] | ||
#![feature(core_simd)] | ||
#![feature(fnbox)] | ||
#![feature(heap_api)] | ||
#![feature(int_error_internals)] | ||
#![feature(into_cow)] | ||
#![feature(iter_order)] | ||
#![feature(lang_items)] | ||
#![feature(libc)] | ||
#![feature(linkage, thread_local, asm)] | ||
#![feature(macro_reexport)] | ||
#![feature(slice_concat_ext)] | ||
#![feature(slice_position_elem)] | ||
#![feature(no_std)] | ||
#![feature(oom)] | ||
#![feature(optin_builtin_traits)] | ||
#![feature(rand)] | ||
#![feature(raw)] | ||
#![feature(reflect_marker)] | ||
#![feature(slice_bytes)] | ||
#![feature(slice_patterns)] | ||
#![feature(staged_api)] | ||
#![feature(str_char)] | ||
#![feature(str_internals)] | ||
#![feature(unboxed_closures)] | ||
#![feature(unicode)] | ||
#![feature(unique)] | ||
#![feature(unsafe_no_drop_flag, filling_drop)] | ||
#![feature(vec_push_all)] | ||
#![feature(vec_resize)] | ||
#![feature(wrapping)] | ||
#![feature(zero_one)] | ||
#![cfg_attr(windows, feature(str_utf16))] | ||
#![cfg_attr(test, feature(float_from_str_radix, range_inclusive, float_extras))] | ||
#![cfg_attr(test, feature(test, rustc_private, float_consts))] | ||
#![cfg_attr(target_env = "msvc", feature(link_args))] | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
// Don't link to std. We are std. | ||
#![no_std] | ||
This comment has been minimized.
Sorry, something went wrong. |
||
|
||
#![allow(trivial_casts)] | ||
#![deny(missing_docs)] | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
#[cfg(test)] extern crate test; | ||
#[cfg(test)] #[macro_use] extern crate log; | ||
|
||
#[macro_use] | ||
#[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq, | ||
unreachable, unimplemented, write, writeln)] | ||
extern crate core; | ||
|
||
#[macro_use] | ||
#[macro_reexport(vec, format)] | ||
extern crate collections as core_collections; | ||
|
||
#[allow(deprecated)] extern crate rand as core_rand; | ||
extern crate alloc; | ||
extern crate rustc_unicode; | ||
extern crate libc; | ||
|
||
#[macro_use] #[no_link] extern crate rustc_bitflags; | ||
|
||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
// Make std testable by not duplicating lang items. See #2912 | ||
#[cfg(test)] extern crate std as realstd; | ||
#[cfg(test)] pub use realstd::marker; | ||
#[cfg(test)] pub use realstd::ops; | ||
#[cfg(test)] pub use realstd::cmp; | ||
#[cfg(test)] pub use realstd::boxed; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
|
||
// NB: These reexports are in the order they should be listed in rustdoc | ||
|
||
pub use core::any; | ||
pub use core::cell; | ||
pub use core::clone; | ||
#[cfg(not(test))] pub use core::cmp; | ||
pub use core::convert; | ||
pub use core::default; | ||
pub use core::hash; | ||
pub use core::intrinsics; | ||
pub use core::iter; | ||
#[cfg(not(test))] pub use core::marker; | ||
pub use core::mem; | ||
#[cfg(not(test))] pub use core::ops; | ||
pub use core::ptr; | ||
pub use core::raw; | ||
pub use core::simd; | ||
pub use core::result; | ||
pub use core::option; | ||
pub mod error; | ||
|
||
#[cfg(not(test))] pub use alloc::boxed; | ||
pub use alloc::rc; | ||
|
||
pub use core_collections::borrow; | ||
pub use core_collections::fmt; | ||
pub use core_collections::slice; | ||
pub use core_collections::str; | ||
pub use core_collections::string; | ||
#[stable(feature = "rust1", since = "1.0.0")] | ||
pub use core_collections::vec; | ||
|
||
pub use rustc_unicode::char; | ||
|
||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
/* Exported macros */ | ||
|
||
#[macro_use] | ||
mod macros; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
mod rtdeps; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
/* The Prelude. */ | ||
|
||
pub mod prelude; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
|
||
/* Primitive types */ | ||
|
||
// NB: slice and str are primitive types too, but their module docs + primitive doc pages | ||
// are inlined from the public re-exports of core_collections::{slice, str} above. | ||
|
||
#[path = "num/float_macros.rs"] | ||
#[macro_use] | ||
mod float_macros; | ||
|
||
#[path = "num/int_macros.rs"] | ||
#[macro_use] | ||
mod int_macros; | ||
|
||
#[path = "num/uint_macros.rs"] | ||
#[macro_use] | ||
mod uint_macros; | ||
|
||
#[path = "num/isize.rs"] pub mod isize; | ||
#[path = "num/i8.rs"] pub mod i8; | ||
#[path = "num/i16.rs"] pub mod i16; | ||
#[path = "num/i32.rs"] pub mod i32; | ||
#[path = "num/i64.rs"] pub mod i64; | ||
|
||
#[path = "num/usize.rs"] pub mod usize; | ||
#[path = "num/u8.rs"] pub mod u8; | ||
#[path = "num/u16.rs"] pub mod u16; | ||
#[path = "num/u32.rs"] pub mod u32; | ||
#[path = "num/u64.rs"] pub mod u64; | ||
|
||
#[path = "num/f32.rs"] pub mod f32; | ||
#[path = "num/f64.rs"] pub mod f64; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
pub mod ascii; | ||
|
||
pub mod thunk; | ||
|
||
/* Common traits */ | ||
|
||
pub mod num; | ||
|
||
/* Runtime and platform support */ | ||
|
||
#[macro_use] | ||
pub mod thread; | ||
|
||
pub mod collections; | ||
pub mod dynamic_lib; | ||
pub mod env; | ||
pub mod ffi; | ||
pub mod fs; | ||
pub mod io; | ||
pub mod net; | ||
pub mod os; | ||
pub mod path; | ||
pub mod process; | ||
pub mod sync; | ||
pub mod time; | ||
|
||
#[macro_use] | ||
#[path = "sys/common/mod.rs"] mod sys_common; | ||
|
||
#[cfg(unix)] | ||
#[path = "sys/unix/mod.rs"] mod sys; | ||
#[cfg(windows)] | ||
#[path = "sys/windows/mod.rs"] mod sys; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
pub mod rt; | ||
mod panicking; | ||
mod rand; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
// Some external utilities of the standard library rely on randomness (aka | ||
// rustc_back::TempDir and tests) and need a way to get at the OS rng we've got | ||
// here. This module is not at all intended for stabilization as-is, however, | ||
// but it may be stabilized long-term. As a result we're exposing a hidden, | ||
// unstable module so we can get our build working. | ||
#[doc(hidden)] | ||
#[unstable(feature = "rand")] | ||
pub mod __rand { | ||
pub use rand::{thread_rng, ThreadRng, Rng}; | ||
} | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
// Modules that exist purely to document + host impl docs for primitive types | ||
|
||
mod array; | ||
mod bool; | ||
mod unit; | ||
mod tuple; | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
||
|
||
// A curious inner-module that's not exported that contains the binding | ||
// 'std' so that macro-expanded references to std::error and such | ||
// can be resolved within libstd. | ||
#[doc(hidden)] | ||
mod std { | ||
pub use sync; // used for select!() | ||
pub use error; // used for try!() | ||
pub use fmt; // used for any formatting strings | ||
pub use option; // used for thread_local!{} | ||
pub use rt; // used for panic!() | ||
pub use vec; // used for vec![] | ||
pub use cell; // used for tls! | ||
pub use thread; // used for thread_local! | ||
pub use marker; // used for tls! | ||
|
||
// The test runner calls ::std::env::args() but really wants realstd | ||
#[cfg(test)] pub use realstd::env as env; | ||
// The test runner requires std::slice::Vector, so re-export std::slice just for it. | ||
// | ||
// It is also used in vec![] | ||
pub use slice; | ||
|
||
pub use boxed; // used for vec![] | ||
} | ||
This comment has been minimized.
Sorry, something went wrong.
brson
Author
Owner
|
The Rust license header. This is on pretty much everything maintained by The Rust Project itself.
Rust has an unusual dual license: MIT and/or Apache 2. The Apache license is included because it ensures important patent grants from contributors, while MIT is left as an option because Apache 2 is not GPL 2 compatible (though it is GPL 3 and LGPL 2). Rust was relicensed in November 2012 from MIT-only.
Note that the date says 2012-2014 even though certainly somebody modified this file in 2015. There is occasional discussion about the amount of effort that should be expended on updating these headers and the current consensus is 'none'.