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.
15 //! It is linked to all Rust crates by default.
17 //! ## Intrinsic types and operations
19 //! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html)
20 //! modules deal with unsafe pointers and memory manipulation.
21 //! [`kinds`](kinds/index.html) defines the special built-in traits,
22 //! and [`raw`](raw/index.html) the runtime representation of Rust types.
23 //! These are some of the lowest-level building blocks in Rust.
25 //! ## Math on primitive types and math traits
27 //! Although basic operations on primitive types are implemented
28 //! directly by the compiler, the standard library additionally
29 //! defines many common operations through traits defined in
30 //! mod [`num`](num/index.html).
32 //! ## Pervasive types
34 //! The [`option`](option/index.html) and [`result`](result/index.html)
35 //! modules define optional and error-handling types, `Option` and `Result`.
36 //! [`iter`](iter/index.html) defines Rust's iterator protocol
37 //! along with a wide variety of iterators.
38 //! [`Cell` and `RefCell`](cell/index.html) are for creating types that
39 //! manage their own mutability.
41 //! ## Vectors, slices and strings
43 //! The common container type, `Vec`, a growable vector backed by an
44 //! array, lives in the [`vec`](vec/index.html) module. References to
45 //! arrays, `&[T]`, more commonly called "slices", are built-in types
46 //! for which the [`slice`](slice/index.html) module defines many
49 //! `&str`, a UTF-8 string, is a built-in type, and the standard library
50 //! defines methods for it on a variety of traits in the
51 //! [`str`](str/index.html) module. Rust strings are immutable;
52 //! use the `String` type defined in [`string`](string/index.html)
53 //! for a mutable string builder.
55 //! For converting to strings use the [`format!`](fmt/index.html)
56 //! macro, and for converting from strings use the
57 //! [`FromStr`](from_str/index.html) trait.
59 //! ## Platform abstractions
61 //! Besides basic data types, the standard library is largely concerned
62 //! with abstracting over differences in common platforms, most notably
63 //! Windows and Unix derivatives. The [`os`](os/index.html) module
64 //! provides a number of basic functions for interacting with the
65 //! operating environment, including program arguments, environment
66 //! variables, and directory navigation. The [`path`](path/index.html)
67 //! module encapsulates the platform-specific rules for dealing
70 //! `std` also includes modules for interoperating with the
71 //! C language: [`c_str`](c_str/index.html) and
72 //! [`c_vec`](c_vec/index.html).
74 //! ## Concurrency, I/O, and the runtime
76 //! The [`task`](task/index.html) module contains Rust's threading abstractions,
77 //! while [`comm`](comm/index.html) contains the channel types for message
78 //! passing. [`sync`](sync/index.html) contains further, primitive, shared
79 //! memory types, including [`atomics`](sync/atomics/index.html).
81 //! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
82 //! timers, and process spawning, are defined in the [`io`](io/index.html) module.
84 //! Rust's I/O and concurrency depends on a small runtime interface
85 //! that lives, along with its support code, in mod [`rt`](rt/index.html).
86 //! While a notable part of the standard library's architecture, this
87 //! module is not intended for public use.
89 //! ## The Rust prelude and macros
91 //! Finally, the [`prelude`](prelude/index.html) defines a
92 //! common set of traits, types, and functions that are made available
93 //! to all code by default. [`macros`](macros/index.html) contains
94 //! all the standard macros, such as `assert!`, `fail!`, `println!`,
95 //! and `format!`, also available to all Rust code.
97 #![crate_name = "std"]
99 #![comment = "The Rust standard library"]
100 #![license = "MIT/ASL2"]
101 #![crate_type = "rlib"]
102 #![crate_type = "dylib"]
103 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
104 html_favicon_url = "http://www.rust-lang.org/favicon.ico",
105 html_root_url = "http://doc.rust-lang.org/master/",
106 html_playground_url = "http://play.rust-lang.org/")]
108 #![feature(macro_rules, globs, managed_boxes, linkage)]
109 #![feature(default_type_params, phase, lang_items, unsafe_destructor)]
110 #![feature(import_shadowing)]
112 // Don't link to std. We are std.
115 // NOTE(stage0, pcwalton): Remove after snapshot.
116 #![allow(unknown_features)]
118 #![allow(deprecated)]
119 #![deny(missing_doc)]
121 #![reexport_test_harness_main = "test_main"]
123 // When testing libstd, bring in libuv as the I/O backend so tests can print
124 // things and all of the std::io tests have an I/O interface to run on top
126 #[cfg(test)] extern crate rustuv;
127 #[cfg(test)] extern crate native;
128 #[cfg(test)] extern crate green;
129 #[cfg(test)] extern crate debug;
130 #[cfg(test)] #[phase(plugin, link)] extern crate log;
133 extern crate unicode;
135 extern crate core_collections = "collections";
136 extern crate core_rand = "rand";
137 extern crate core_sync = "sync";
141 // Make std testable by not duplicating lang items. See #2912
142 #[cfg(test)] extern crate realstd = "std";
143 #[cfg(test)] pub use realstd::kinds;
144 #[cfg(test)] pub use realstd::ops;
145 #[cfg(test)] pub use realstd::cmp;
146 #[cfg(test)] pub use realstd::ty;
147 #[cfg(test)] pub use realstd::boxed;
148 #[cfg(test)] pub use realstd::gc;
151 // NB: These reexports are in the order they should be listed in rustdoc
157 #[cfg(not(test))] pub use core::cmp;
158 pub use core::default;
159 pub use core::finally;
160 pub use core::intrinsics;
162 #[cfg(not(test))] pub use core::kinds;
164 #[cfg(not(test))] pub use core::ops;
169 // FIXME #15320: primitive documentation needs top-level modules, this
170 // should be `std::tuple::unit`.
172 #[cfg(not(test))] pub use core::ty;
173 pub use core::result;
174 pub use core::option;
176 pub use alloc::boxed;
177 #[deprecated = "use boxed instead"]
178 pub use boxed as owned;
182 pub use core_collections::slice;
183 pub use core_collections::str;
184 pub use core_collections::string;
185 pub use core_collections::vec;
187 pub use rustrt::c_str;
188 pub use rustrt::local_data;
190 pub use unicode::char;
192 pub use core_sync::comm;
194 // Run tests with libgreen instead of libnative.
195 #[cfg(test)] #[start]
196 fn start(argc: int, argv: *const *const u8) -> int {
197 green::start(argc, argv, rustuv::event_loop, test_main)
200 /* Exported macros */
212 /* Primitive types */
214 #[path = "num/float_macros.rs"] mod float_macros;
215 #[path = "num/int_macros.rs"] mod int_macros;
216 #[path = "num/uint_macros.rs"] mod uint_macros;
218 #[path = "num/int.rs"] pub mod int;
219 #[path = "num/i8.rs"] pub mod i8;
220 #[path = "num/i16.rs"] pub mod i16;
221 #[path = "num/i32.rs"] pub mod i32;
222 #[path = "num/i64.rs"] pub mod i64;
224 #[path = "num/uint.rs"] pub mod uint;
225 #[path = "num/u8.rs"] pub mod u8;
226 #[path = "num/u16.rs"] pub mod u16;
227 #[path = "num/u32.rs"] pub mod u32;
228 #[path = "num/u64.rs"] pub mod u64;
230 #[path = "num/f32.rs"] pub mod f32;
231 #[path = "num/f64.rs"] pub mod f64;
248 /* Common data structures */
253 /* Tasks and communication */
258 /* Runtime and platform support */
267 // FIXME #7809: This shouldn't be pub, and it should be reexported under 'unstable'
268 // but name resolution doesn't work without it being pub.
273 // A curious inner-module that's not exported that contains the binding
274 // 'std' so that macro-expanded references to std::error and such
275 // can be resolved within libstd.
278 // mods used for deriving
283 pub use comm; // used for select!()
284 pub use fmt; // used for any formatting strings
285 pub use io; // used for println!()
286 pub use local_data; // used for local_data_key!()
287 pub use option; // used for bitflags!()
288 pub use rt; // used for fail!()
289 pub use vec; // used for vec![]
291 // The test runner calls ::std::os::args() but really wants realstd
292 #[cfg(test)] pub use realstd::os as os;
293 // The test runner requires std::slice::Vector, so re-export std::slice just for it.
294 #[cfg(test)] pub use slice;
296 pub use collections; // vec!() uses MutableSeq