src/libstd/lib.rs

   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.
   4 //
   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.
  10
  11 //! # The Rust Standard Library
  12 //!
  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.
  16 //!
  17 //! ## Intrinsic types and operations
  18 //!
  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.
  24 //!
  25 //! ## Math on primitive types and math traits
  26 //!
  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).
  31 //!
  32 //! ## Pervasive types
  33 //!
  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.
  40 //!
  41 //! ## Vectors, slices and strings
  42 //!
  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
  47 //! methods.
  48 //!
  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.
  54 //!
  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.
  58 //!
  59 //! ## Platform abstractions
  60 //!
  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
  68 //! with file paths.
  69 //!
  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).
  73 //!
  74 //! ## Concurrency, I/O, and the runtime
  75 //!
  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).
  80 //!
  81 //! Common types of I/O, including files, TCP, UPD, pipes, Unix domain sockets,
  82 //! timers, and process spawning, are defined in the [`io`](io/index.html) module.
  83 //!
  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.
  88 //!
  89 //! ## The Rust prelude and macros
  90 //!
  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.
  96
  97 #![crate_id = "std#0.11.0-pre"]
  98 #![unstable]
  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/",
 106        html_playground_url = "http://play.rust-lang.org/")]
 107
 108 #![feature(macro_rules, globs, managed_boxes, linkage)]
 109 #![feature(default_type_params, phase, lang_items, unsafe_destructor)]
 110
 111 // Don't link to std. We are std.
 112 #![no_std]
 113
 114 #![allow(deprecated)]
 115 #![deny(missing_doc)]
 116
 117 // When testing libstd, bring in libuv as the I/O backend so tests can print
 118 // things and all of the std::io tests have an I/O interface to run on top
 119 // of
 120 #[cfg(test)] extern crate rustuv;
 121 #[cfg(test)] extern crate native;
 122 #[cfg(test)] extern crate green;
 123 #[cfg(test)] extern crate debug;
 124 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 125
 126 extern crate alloc;
 127 extern crate core;
 128 extern crate core_collections = "collections";
 129 extern crate core_rand = "rand";
 130 extern crate core_sync = "sync";
 131 extern crate libc;
 132 extern crate rustrt;
 133
 134 // Make std testable by not duplicating lang items. See #2912
 135 #[cfg(test)] extern crate realstd = "std";
 136 #[cfg(test)] pub use realstd::kinds;
 137 #[cfg(test)] pub use realstd::ops;
 138 #[cfg(test)] pub use realstd::cmp;
 139 #[cfg(test)] pub use realstd::ty;
 140 #[cfg(test)] pub use realstd::owned;
 141 #[cfg(test)] pub use realstd::gc;
 142
 143
 144 // NB: These reexports are in the order they should be listed in rustdoc
 145
 146 pub use core::any;
 147 pub use core::bool;
 148 pub use core::cell;
 149 pub use core::char;
 150 pub use core::clone;
 151 #[cfg(not(test))] pub use core::cmp;
 152 pub use core::default;
 153 pub use core::finally;
 154 pub use core::intrinsics;
 155 pub use core::iter;
 156 #[cfg(not(test))] pub use core::kinds;
 157 pub use core::mem;
 158 #[cfg(not(test))] pub use core::ops;
 159 pub use core::ptr;
 160 pub use core::raw;
 161 pub use core::simd;
 162 pub use core::tuple;
 163 #[cfg(not(test))] pub use core::ty;
 164 pub use core::result;
 165 pub use core::option;
 166
 167 pub use alloc::owned;
 168 pub use alloc::rc;
 169
 170 pub use core_collections::slice;
 171 pub use core_collections::str;
 172 pub use core_collections::string;
 173 pub use core_collections::vec;
 174
 175 pub use rustrt::c_str;
 176 pub use rustrt::local_data;
 177
 178 pub use core_sync::comm;
 179
 180 // Run tests with libgreen instead of libnative.
 181 //
 182 // FIXME: This egregiously hacks around starting the test runner in a different
 183 //        threading mode than the default by reaching into the auto-generated
 184 //        '__test' module.
 185 #[cfg(test)] #[start]
 186 fn start(argc: int, argv: *const *const u8) -> int {
 187     green::start(argc, argv, rustuv::event_loop, __test::main)
 188 }
 189
 190 /* Exported macros */
 191
 192 pub mod macros;
 193 pub mod bitflags;
 194
 195 mod rtdeps;
 196
 197 /* The Prelude. */
 198
 199 pub mod prelude;
 200
 201
 202 /* Primitive types */
 203
 204 #[path = "num/float_macros.rs"] mod float_macros;
 205 #[path = "num/int_macros.rs"]   mod int_macros;
 206 #[path = "num/uint_macros.rs"]  mod uint_macros;
 207
 208 #[path = "num/int.rs"]  pub mod int;
 209 #[path = "num/i8.rs"]   pub mod i8;
 210 #[path = "num/i16.rs"]  pub mod i16;
 211 #[path = "num/i32.rs"]  pub mod i32;
 212 #[path = "num/i64.rs"]  pub mod i64;
 213
 214 #[path = "num/uint.rs"] pub mod uint;
 215 #[path = "num/u8.rs"]   pub mod u8;
 216 #[path = "num/u16.rs"]  pub mod u16;
 217 #[path = "num/u32.rs"]  pub mod u32;
 218 #[path = "num/u64.rs"]  pub mod u64;
 219
 220 #[path = "num/f32.rs"]   pub mod f32;
 221 #[path = "num/f64.rs"]   pub mod f64;
 222
 223 pub mod rand;
 224
 225 pub mod ascii;
 226
 227 #[cfg(not(test))]
 228 pub mod gc;
 229
 230 /* Common traits */
 231
 232 pub mod from_str;
 233 pub mod num;
 234 pub mod to_str;
 235
 236 /* Common data structures */
 237
 238 pub mod collections;
 239 pub mod hash;
 240
 241 /* Tasks and communication */
 242
 243 pub mod task;
 244 pub mod sync;
 245
 246 /* Runtime and platform support */
 247
 248 pub mod c_vec;
 249 pub mod dynamic_lib;
 250 pub mod os;
 251 pub mod io;
 252 pub mod path;
 253 pub mod fmt;
 254
 255 // FIXME #7809: This shouldn't be pub, and it should be reexported under 'unstable'
 256 // but name resolution doesn't work without it being pub.
 257 #[unstable]
 258 pub mod rt;
 259 mod failure;
 260
 261 // A curious inner-module that's not exported that contains the binding
 262 // 'std' so that macro-expanded references to std::error and such
 263 // can be resolved within libstd.
 264 #[doc(hidden)]
 265 mod std {
 266     // mods used for deriving
 267     pub use clone;
 268     pub use cmp;
 269     pub use hash;
 270
 271     pub use comm; // used for select!()
 272     pub use fmt; // used for any formatting strings
 273     pub use io; // used for println!()
 274     pub use local_data; // used for local_data_key!()
 275     pub use option; // used for bitflags!()
 276     pub use rt; // used for fail!()
 277     pub use vec; // used for vec![]
 278
 279     // The test runner calls ::std::os::args() but really wants realstd
 280     #[cfg(test)] pub use os = realstd::os;
 281     // The test runner requires std::slice::Vector, so re-export std::slice just for it.
 282     #[cfg(test)] pub use slice;
 283 }
 284
 285 #[deprecated]
 286 #[allow(missing_doc)]
 287 #[doc(hiden)]
 288 pub mod unstable {
 289     #[deprecated = "use std::dynamic_lib"]
 290     pub use dynamic_lib;
 291 }