1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! # The Rust Standard Library
13 //! The Rust Standard Library provides the essential runtime
14 //! functionality for building portable Rust software.
16 //! The Rust Standard Library is available to all Rust crates by
17 //! default, just as if contained an `extern crate std` import at the
18 //! crate root. Therefore the standard library can be accessed in
19 //! `use` statements through the path `std`, as in `use std::thread`,
20 //! or in expressions through the absolute path `::std`, as in
21 //! `::std::thread::sleep_ms(100)`.
23 //! Furthermore, the standard library defines [The Rust
24 //! Prelude](prelude/index.html), a small collection of items, mostly
25 //! traits, that are imported into and available in every module.
27 //! ## What is in the standard library
29 //! The standard library is a set of minimal, battle-tested
30 //! core types and shared abstractions for the [broader Rust
31 //! ecosystem](https://crates.io) to build on.
33 //! The [primitive types](#primitives), though not defined in the
34 //! standard library, are documented here, as are the predefined
35 //! [macros](#macros).
37 //! ## Containers and collections
39 //! The [`option`](option/index.html) and
40 //! [`result`](result/index.html) modules define optional and
41 //! error-handling types, `Option` and `Result`. The
42 //! [`iter`](iter/index.html) module defines Rust's iterator trait,
43 //! [`Iterator`](iter/trait.Iterator.html), which works with the `for`
44 //! loop to access collections.
46 //! The common container type, `Vec`, a growable vector backed by an array,
47 //! lives in the [`vec`](vec/index.html) module. Contiguous, unsized regions
48 //! of memory, `[T]`, commonly called "slices", and their borrowed versions,
49 //! `&[T]`, commonly called "borrowed slices", are built-in types for which the
50 //! [`slice`](slice/index.html) module defines many methods.
52 //! `&str`, a UTF-8 string, is a built-in type, and the standard library
53 //! defines methods for it on a variety of traits in the
54 //! [`str`](str/index.html) module. Rust strings are immutable;
55 //! use the `String` type defined in [`string`](string/index.html)
56 //! for a mutable string builder.
58 //! For converting to strings use the [`format!`](fmt/index.html)
59 //! macro, and for converting from strings use the
60 //! [`FromStr`](str/trait.FromStr.html) trait.
62 //! Data may be shared by placing it in a reference-counted box or the
63 //! [`Rc`](rc/index.html) type, and if further contained in a [`Cell`
64 //! or `RefCell`](cell/index.html), may be mutated as well as shared.
65 //! Likewise, in a concurrent setting it is common to pair an
66 //! atomically-reference-counted box, [`Arc`](sync/struct.Arc.html),
67 //! with a [`Mutex`](sync/struct.Mutex.html) to get the same effect.
69 //! The [`collections`](collections/index.html) module defines maps,
70 //! sets, linked lists and other typical collection types, including
71 //! the common [`HashMap`](collections/struct.HashMap.html).
73 //! ## Platform abstractions and I/O
75 //! Besides basic data types, the standard library is largely concerned
76 //! with abstracting over differences in common platforms, most notably
77 //! Windows and Unix derivatives.
79 //! Common types of I/O, including [files](fs/struct.File.html),
80 //! [TCP](net/struct.TcpStream.html),
81 //! [UDP](net/struct.UdpSocket.html), are defined in the
82 //! [`io`](io/index.html), [`fs`](fs/index.html), and
83 //! [`net`](net/index.html) modules.
85 //! The [`thread`](thread/index.html) module contains Rust's threading
86 //! abstractions. [`sync`](sync/index.html) contains further
87 //! primitive shared memory types, including
88 //! [`atomic`](sync/atomic/index.html) and
89 //! [`mpsc`](sync/mpsc/index.html), which contains the channel types
90 //! for message passing.
92 // Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
93 #![cfg_attr(stage0, feature(custom_attribute))]
94 #![crate_name = "std"]
95 #![stable(feature = "rust1", since = "1.0.0")]
97 #![crate_type = "rlib"]
98 #![crate_type = "dylib"]
99 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
100 html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
101 html_root_url = "http://doc.rust-lang.org/nightly/",
102 html_playground_url = "http://play.rust-lang.org/",
103 test(no_crate_inject, attr(deny(warnings))),
104 test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))]
107 #![feature(allow_internal_unstable)]
108 #![feature(associated_consts)]
109 #![feature(borrow_state)]
111 #![feature(box_syntax)]
112 #![feature(char_internals)]
113 #![feature(clone_from_slice)]
114 #![feature(collections)]
115 #![feature(collections_bound)]
116 #![feature(const_fn)]
118 #![feature(core_float)]
119 #![feature(core_intrinsics)]
120 #![feature(core_prelude)]
121 #![feature(core_simd)]
123 #![feature(heap_api)]
124 #![feature(int_error_internals)]
125 #![feature(into_cow)]
126 #![feature(iter_order)]
127 #![feature(lang_items)]
129 #![feature(linkage, thread_local, asm)]
130 #![feature(macro_reexport)]
131 #![feature(slice_concat_ext)]
132 #![feature(slice_position_elem)]
135 #![feature(optin_builtin_traits)]
138 #![feature(reflect_marker)]
139 #![feature(slice_bytes)]
140 #![feature(slice_patterns)]
141 #![feature(staged_api)]
142 #![feature(str_char)]
143 #![feature(str_internals)]
144 #![feature(unboxed_closures)]
147 #![feature(unsafe_no_drop_flag, filling_drop)]
148 #![feature(vec_push_all)]
149 #![feature(vec_resize)]
150 #![feature(wrapping)]
151 #![feature(zero_one)]
152 #![cfg_attr(windows, feature(str_utf16))]
153 #![cfg_attr(test, feature(float_from_str_radix, range_inclusive, float_extras, hash_default))]
154 #![cfg_attr(test, feature(test, rustc_private, float_consts))]
155 #![cfg_attr(target_env = "msvc", feature(link_args))]
157 // Don't link to std. We are std.
160 #![allow(trivial_casts)]
161 #![deny(missing_docs)]
163 #[cfg(test)] extern crate test;
164 #[cfg(test)] #[macro_use] extern crate log;
167 #[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq,
168 unreachable, unimplemented, write, writeln)]
172 #[macro_reexport(vec, format)]
173 extern crate collections as core_collections;
175 #[allow(deprecated)] extern crate rand as core_rand;
177 extern crate rustc_unicode;
180 #[macro_use] #[no_link] extern crate rustc_bitflags;
182 // Make std testable by not duplicating lang items and other globals. See #2912
183 #[cfg(test)] extern crate std as realstd;
185 // NB: These reexports are in the order they should be listed in rustdoc
191 pub use core::convert;
192 pub use core::default;
194 pub use core::intrinsics;
196 pub use core::marker;
202 pub use core::result;
203 pub use core::option;
206 pub use alloc::boxed;
209 pub use core_collections::borrow;
210 pub use core_collections::fmt;
211 pub use core_collections::slice;
212 pub use core_collections::str;
213 pub use core_collections::string;
214 #[stable(feature = "rust1", since = "1.0.0")]
215 pub use core_collections::vec;
217 pub use rustc_unicode::char;
219 /* Exported macros */
231 /* Primitive types */
233 // NB: slice and str are primitive types too, but their module docs + primitive doc pages
234 // are inlined from the public re-exports of core_collections::{slice, str} above.
236 #[path = "num/float_macros.rs"]
240 #[path = "num/int_macros.rs"]
244 #[path = "num/uint_macros.rs"]
248 #[path = "num/isize.rs"] pub mod isize;
249 #[path = "num/i8.rs"] pub mod i8;
250 #[path = "num/i16.rs"] pub mod i16;
251 #[path = "num/i32.rs"] pub mod i32;
252 #[path = "num/i64.rs"] pub mod i64;
254 #[path = "num/usize.rs"] pub mod usize;
255 #[path = "num/u8.rs"] pub mod u8;
256 #[path = "num/u16.rs"] pub mod u16;
257 #[path = "num/u32.rs"] pub mod u32;
258 #[path = "num/u64.rs"] pub mod u64;
260 #[path = "num/f32.rs"] pub mod f32;
261 #[path = "num/f64.rs"] pub mod f64;
271 /* Runtime and platform support */
290 #[path = "sys/common/mod.rs"] mod sys_common;
293 #[path = "sys/unix/mod.rs"] mod sys;
295 #[path = "sys/windows/mod.rs"] mod sys;
301 // Some external utilities of the standard library rely on randomness (aka
302 // rustc_back::TempDir and tests) and need a way to get at the OS rng we've got
303 // here. This module is not at all intended for stabilization as-is, however,
304 // but it may be stabilized long-term. As a result we're exposing a hidden,
305 // unstable module so we can get our build working.
307 #[unstable(feature = "rand")]
309 pub use rand::{thread_rng, ThreadRng, Rng};
312 // Modules that exist purely to document + host impl docs for primitive types
319 // A curious inner-module that's not exported that contains the binding
320 // 'std' so that macro-expanded references to std::error and such
321 // can be resolved within libstd.
324 pub use sync; // used for select!()
325 pub use error; // used for try!()
326 pub use fmt; // used for any formatting strings
327 pub use option; // used for thread_local!{}
328 pub use rt; // used for panic!()
329 pub use vec; // used for vec![]
330 pub use cell; // used for tls!
331 pub use thread; // used for thread_local!
332 pub use marker; // used for tls!
334 // The test runner calls ::std::env::args() but really wants realstd
335 #[cfg(test)] pub use realstd::env as env;
336 // The test runner requires std::slice::Vector, so re-export std::slice just for it.
338 // It is also used in vec![]
341 pub use boxed; // used for vec![]