]> git.proxmox.com Git - rustc.git/blame - src/libstd/lib.rs
New upstream version 1.41.1+dfsg1
[rustc.git] / src / libstd / lib.rs
CommitLineData
1a4d82fc
JJ
1//! # The Rust Standard Library
2//!
92a42be0
SL
3//! The Rust Standard Library is the foundation of portable Rust software, a
4//! set of minimal and battle-tested shared abstractions for the [broader Rust
5//! ecosystem][crates.io]. It offers core types, like [`Vec<T>`] and
6//! [`Option<T>`], library-defined [operations on language
7//! primitives](#primitives), [standard macros](#macros), [I/O] and
8//! [multithreading], among [many other things][other].
9//!
9fa01778 10//! `std` is available to all Rust crates by default. Therefore, the
92a42be0 11//! standard library can be accessed in [`use`] statements through the path
9fa01778 12//! `std`, as in [`use std::env`].
1a4d82fc 13//!
c1a9b12d 14//! # How to read this documentation
1a4d82fc 15//!
9cc50fc6 16//! If you already know the name of what you are looking for, the fastest way to
92a42be0
SL
17//! find it is to use the <a href="#" onclick="focusSearchBar();">search
18//! bar</a> at the top of the page.
1a4d82fc 19//!
c1a9b12d
SL
20//! Otherwise, you may want to jump to one of these useful sections:
21//!
22//! * [`std::*` modules](#modules)
23//! * [Primitive types](#primitives)
24//! * [Standard macros](#macros)
25//! * [The Rust Prelude](prelude/index.html)
26//!
92a42be0
SL
27//! If this is your first time, the documentation for the standard library is
28//! written to be casually perused. Clicking on interesting things should
29//! generally lead you to interesting places. Still, there are important bits
30//! you don't want to miss, so read on for a tour of the standard library and
31//! its documentation!
c1a9b12d 32//!
92a42be0
SL
33//! Once you are familiar with the contents of the standard library you may
34//! begin to find the verbosity of the prose distracting. At this stage in your
83c7162d 35//! development you may want to press the `[-]` button near the top of the
92a42be0 36//! page to collapse it into a more skimmable view.
c1a9b12d 37//!
83c7162d 38//! While you are looking at that `[-]` button also notice the `[src]`
92a42be0
SL
39//! button. Rust's API documentation comes with the source code and you are
40//! encouraged to read it. The standard library source is generally high
41//! quality and a peek behind the curtains is often enlightening.
c1a9b12d
SL
42//!
43//! # What is in the standard library documentation?
44//!
92a42be0
SL
45//! First of all, The Rust Standard Library is divided into a number of focused
46//! modules, [all listed further down this page](#modules). These modules are
47//! the bedrock upon which all of Rust is forged, and they have mighty names
48//! like [`std::slice`] and [`std::cmp`]. Modules' documentation typically
49//! includes an overview of the module along with examples, and are a smart
50//! place to start familiarizing yourself with the library.
c1a9b12d 51//!
92a42be0 52//! Second, implicit methods on [primitive types] are documented here. This can
c1a9b12d
SL
53//! be a source of confusion for two reasons:
54//!
92a42be0
SL
55//! 1. While primitives are implemented by the compiler, the standard library
56//! implements methods directly on the primitive types (and it is the only
57//! library that does so), which are [documented in the section on
58//! primitives](#primitives).
59//! 2. The standard library exports many modules *with the same name as
60//! primitive types*. These define additional items related to the primitive
61//! type, but not the all-important methods.
c1a9b12d
SL
62//!
63//! So for example there is a [page for the primitive type
92a42be0
SL
64//! `i32`](primitive.i32.html) that lists all the methods that can be called on
65//! 32-bit integers (very useful), and there is a [page for the module
66//! `std::i32`](i32/index.html) that documents the constant values [`MIN`] and
67//! [`MAX`](i32/constant.MAX.html) (rarely useful).
68//!
69//! Note the documentation for the primitives [`str`] and [`[T]`][slice] (also
70//! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually
71//! calls to methods on [`str`] and [`[T]`][slice] respectively, via [deref
3b2f2976 72//! coercions][deref-coercions].
92a42be0
SL
73//!
74//! Third, the standard library defines [The Rust Prelude], a small collection
75//! of items - mostly traits - that are imported into every module of every
76//! crate. The traits in the prelude are pervasive, making the prelude
c1a9b12d
SL
77//! documentation a good entry point to learning about the library.
78//!
92a42be0
SL
79//! And finally, the standard library exports a number of standard macros, and
80//! [lists them on this page](#macros) (technically, not all of the standard
81//! macros are defined by the standard library - some are defined by the
82//! compiler - but they are documented here the same). Like the prelude, the
83//! standard macros are imported by default into all crates.
c1a9b12d 84//!
cc61c64b
XL
85//! # Contributing changes to the documentation
86//!
87//! Check out the rust contribution guidelines [here](
88//! https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md).
89//! The source for this documentation can be found on [Github](https://github.com/rust-lang).
90//! To contribute changes, make sure you read the guidelines first, then submit
91//! pull-requests for your suggested changes.
92//!
93//! Contributions are appreciated! If you see a part of the docs that can be
94//! improved, submit a PR, or chat with us first on irc.mozilla.org #rust-docs.
95//!
c1a9b12d
SL
96//! # A Tour of The Rust Standard Library
97//!
92a42be0
SL
98//! The rest of this crate documentation is dedicated to pointing out notable
99//! features of The Rust Standard Library.
1a4d82fc 100//!
bd371182 101//! ## Containers and collections
1a4d82fc 102//!
92a42be0
SL
103//! The [`option`] and [`result`] modules define optional and error-handling
104//! types, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines
105//! Rust's iterator trait, [`Iterator`], which works with the [`for`] loop to
106//! access collections.
1a4d82fc 107//!
92a42be0 108//! The standard library exposes three common ways to deal with contiguous
c1a9b12d
SL
109//! regions of memory:
110//!
92a42be0
SL
111//! * [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.
112//! * [`[T; n]`][array] - An inline *array* with a fixed size at compile time.
113//! * [`[T]`][slice] - A dynamically sized *slice* into any other kind of contiguous
114//! storage, whether heap-allocated or not.
c1a9b12d 115//!
92a42be0
SL
116//! Slices can only be handled through some kind of *pointer*, and as such come
117//! in many flavors such as:
1a4d82fc 118//!
c1a9b12d
SL
119//! * `&[T]` - *shared slice*
120//! * `&mut [T]` - *mutable slice*
92a42be0 121//! * [`Box<[T]>`][owned slice] - *owned slice*
c1a9b12d 122//!
92a42be0
SL
123//! [`str`], a UTF-8 string slice, is a primitive type, and the standard library
124//! defines many methods for it. Rust [`str`]s are typically accessed as
125//! immutable references: `&str`. Use the owned [`String`] for building and
126//! mutating strings.
1a4d82fc 127//!
92a42be0
SL
128//! For converting to strings use the [`format!`] macro, and for converting from
129//! strings use the [`FromStr`] trait.
1a4d82fc 130//!
92a42be0
SL
131//! Data may be shared by placing it in a reference-counted box or the [`Rc`]
132//! type, and if further contained in a [`Cell`] or [`RefCell`], may be mutated
133//! as well as shared. Likewise, in a concurrent setting it is common to pair an
134//! atomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same
135//! effect.
bd371182 136//!
92a42be0
SL
137//! The [`collections`] module defines maps, sets, linked lists and other
138//! typical collection types, including the common [`HashMap<K, V>`].
bd371182
AL
139//!
140//! ## Platform abstractions and I/O
1a4d82fc 141//!
92a42be0
SL
142//! Besides basic data types, the standard library is largely concerned with
143//! abstracting over differences in common platforms, most notably Windows and
144//! Unix derivatives.
145//!
146//! Common types of I/O, including [files], [TCP], [UDP], are defined in the
147//! [`io`], [`fs`], and [`net`] modules.
148//!
149//! The [`thread`] module contains Rust's threading abstractions. [`sync`]
150//! contains further primitive shared memory types, including [`atomic`] and
151//! [`mpsc`], which contains the channel types for message passing.
152//!
153//! [I/O]: io/index.html
9cc50fc6 154//! [`MIN`]: i32/constant.MIN.html
92a42be0
SL
155//! [TCP]: net/struct.TcpStream.html
156//! [The Rust Prelude]: prelude/index.html
157//! [UDP]: net/struct.UdpSocket.html
92a42be0
SL
158//! [`Arc`]: sync/struct.Arc.html
159//! [owned slice]: boxed/index.html
160//! [`Cell`]: cell/struct.Cell.html
161//! [`FromStr`]: str/trait.FromStr.html
162//! [`HashMap<K, V>`]: collections/struct.HashMap.html
163//! [`Iterator`]: iter/trait.Iterator.html
164//! [`Mutex`]: sync/struct.Mutex.html
165//! [`Option<T>`]: option/enum.Option.html
166//! [`Rc`]: rc/index.html
167//! [`RefCell`]: cell/struct.RefCell.html
168//! [`Result<T, E>`]: result/enum.Result.html
169//! [`String`]: string/struct.String.html
170//! [`Vec<T>`]: vec/index.html
171//! [array]: primitive.array.html
172//! [slice]: primitive.slice.html
173//! [`atomic`]: sync/atomic/index.html
174//! [`collections`]: collections/index.html
13cf67c4 175//! [`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
9e0c209e 176//! [`format!`]: macro.format.html
92a42be0
SL
177//! [`fs`]: fs/index.html
178//! [`io`]: io/index.html
179//! [`iter`]: iter/index.html
180//! [`mpsc`]: sync/mpsc/index.html
181//! [`net`]: net/index.html
182//! [`option`]: option/index.html
183//! [`result`]: result/index.html
184//! [`std::cmp`]: cmp/index.html
185//! [`std::slice`]: slice/index.html
186//! [`str`]: primitive.str.html
187//! [`sync`]: sync/index.html
188//! [`thread`]: thread/index.html
189//! [`use std::env`]: env/index.html
532ac7d7 190//! [`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html
92a42be0 191//! [crates.io]: https://crates.io
13cf67c4 192//! [deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods
92a42be0
SL
193//! [files]: fs/struct.File.html
194//! [multithreading]: thread/index.html
195//! [other]: #what-is-in-the-standard-library-documentation
13cf67c4 196//! [primitive types]: ../book/ch03-02-data-types.html
bd371182 197
85aaf69f 198#![stable(feature = "rust1", since = "1.0.0")]
9fa01778 199#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
e9174d1e
SL
200 html_playground_url = "https://play.rust-lang.org/",
201 issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
62682a34
SL
202 test(no_crate_inject, attr(deny(warnings))),
203 test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))]
1a4d82fc 204
c30ab7b3
SL
205// Don't link to std. We are std.
206#![no_std]
207
416331ca 208#![warn(deprecated_in_future)]
48663c56
XL
209#![warn(missing_docs)]
210#![warn(missing_debug_implementations)]
211#![deny(intra_doc_link_resolution_failure)] // rustdoc is run without -D warnings
532ac7d7 212#![allow(explicit_outlives_requirements)]
416331ca 213#![allow(unused_lifetimes)]
532ac7d7 214
c30ab7b3 215// Tell the compiler to link to either panic_abort or panic_unwind
3157f602
XL
216#![needs_panic_runtime]
217
c30ab7b3
SL
218// std may use features in a platform-specific way
219#![allow(unused_features)]
220
416331ca 221#![cfg_attr(test, feature(print_internals, set_stdio, update_panic_count))]
9fa01778 222#![cfg_attr(all(target_vendor = "fortanix", target_env = "sgx"),
e74abb32 223 feature(slice_index_methods, coerce_unsized,
416331ca 224 sgx_platform, ptr_wrapping_offset_from))]
48663c56
XL
225#![cfg_attr(all(test, target_vendor = "fortanix", target_env = "sgx"),
226 feature(fixed_size_array, maybe_uninit_extra))]
9fa01778 227
c30ab7b3
SL
228// std is implemented with unstable features, many of which are internal
229// compiler details that will never be stable
9fa01778 230// NB: the following list is sorted to minimize merge conflicts.
8faf50e0 231#![feature(alloc_error_handler)]
9fa01778 232#![feature(alloc_layout_extra)]
8faf50e0 233#![feature(allocator_api)]
041b39d2 234#![feature(allocator_internals)]
3b2f2976 235#![feature(allow_internal_unsafe)]
d9579d0f 236#![feature(allow_internal_unstable)]
60c5eb7d 237#![feature(atomic_mut_ptr)]
94b46f34 238#![feature(arbitrary_self_types)]
abe05a73 239#![feature(array_error_internals)]
92a42be0 240#![feature(asm)]
416331ca 241#![feature(associated_type_bounds)]
1a4d82fc 242#![feature(box_syntax)]
a1dfa0c6 243#![feature(c_variadic)]
c30ab7b3 244#![feature(cfg_target_has_atomic)]
9cc50fc6 245#![feature(cfg_target_thread_local)]
041b39d2 246#![feature(char_error_internals)]
532ac7d7 247#![feature(clamp)]
0731742a 248#![feature(concat_idents)]
0bf4aa26 249#![feature(const_cstr_unchecked)]
9fa01778 250#![feature(const_raw_ptr_deref)]
e1599b0c 251#![feature(container_error_extra)]
62682a34 252#![feature(core_intrinsics)]
416331ca 253#![feature(custom_test_frameworks)]
e74abb32 254#![feature(decl_macro)]
9fa01778
XL
255#![feature(doc_alias)]
256#![feature(doc_cfg)]
257#![feature(doc_keyword)]
258#![feature(doc_masked)]
259#![feature(doc_spotlight)]
32a655c1 260#![feature(dropck_eyepatch)]
0731742a 261#![feature(duration_constants)]
476ff2be 262#![feature(exact_size_is_empty)]
9fa01778 263#![feature(exhaustive_patterns)]
2c00a5a8 264#![feature(external_doc)]
54a0048b 265#![feature(fn_traits)]
416331ca 266#![feature(format_args_nl)]
8faf50e0 267#![feature(generator_trait)]
416331ca 268#![feature(global_asm)]
9fa01778 269#![feature(hash_raw_entry)]
0531ce1d 270#![feature(hashmap_internals)]
62682a34 271#![feature(int_error_internals)]
48663c56 272#![feature(int_error_matching)]
c30ab7b3 273#![feature(integer_atomics)]
85aaf69f
SL
274#![feature(lang_items)]
275#![feature(libc)]
92a42be0
SL
276#![feature(link_args)]
277#![feature(linkage)]
416331ca 278#![feature(log_syntax)]
e74abb32
XL
279#![feature(manually_drop_take)]
280#![feature(matches_macro)]
416331ca
XL
281#![feature(maybe_uninit_ref)]
282#![feature(maybe_uninit_slice)]
5bcae85e 283#![feature(needs_panic_runtime)]
cc61c64b 284#![feature(never_type)]
0bf4aa26 285#![feature(nll)]
60c5eb7d 286#![cfg_attr(bootstrap, feature(on_unimplemented))]
85aaf69f 287#![feature(optin_builtin_traits)]
9fa01778 288#![feature(panic_info_message)]
0531ce1d 289#![feature(panic_internals)]
a7813a04 290#![feature(panic_unwind)]
9e0c209e 291#![feature(prelude_import)]
2c00a5a8 292#![feature(ptr_internals)]
62682a34 293#![feature(raw)]
9fa01778 294#![feature(renamed_spin_loop)]
54a0048b 295#![feature(rustc_attrs)]
60c5eb7d 296#![cfg_attr(bootstrap, feature(rustc_const_unstable))]
9fa01778 297#![feature(rustc_private)]
0531ce1d 298#![feature(shrink_to)]
92a42be0 299#![feature(slice_concat_ext)]
ff7c6d11 300#![feature(slice_internals)]
d9579d0f 301#![feature(slice_patterns)]
e74abb32 302#![feature(specialization)]
85aaf69f 303#![feature(staged_api)]
9fa01778
XL
304#![feature(std_internals)]
305#![feature(stdsimd)]
9cc50fc6 306#![feature(stmt_expr_attributes)]
62682a34 307#![feature(str_internals)]
416331ca 308#![feature(test)]
92a42be0 309#![feature(thread_local)]
cc61c64b 310#![feature(toowned_clone_into)]
416331ca 311#![feature(trace_macros)]
0531ce1d 312#![feature(try_reserve)]
85aaf69f 313#![feature(unboxed_closures)]
8bb4bdeb 314#![feature(untagged_unions)]
e9174d1e 315#![feature(unwind_attributes)]
9fa01778 316// NB: the above list is sorted to minimize merge conflicts.
ea8adc8c 317
3b2f2976
XL
318#![default_lib_allocator]
319
c30ab7b3
SL
320// Explicitly import the prelude. The compiler uses this same unstable attribute
321// to import the prelude implicitly when building crates that depend on std.
9e0c209e
SL
322#[prelude_import]
323#[allow(unused)]
324use prelude::v1::*;
325
c30ab7b3 326// Access to Bencher, etc.
85aaf69f 327#[cfg(test)] extern crate test;
1a4d82fc 328
83c7162d 329#[allow(unused_imports)] // macros from `alloc` are not used on all platforms
1a4d82fc 330#[macro_use]
83c7162d 331extern crate alloc as alloc_crate;
ea8adc8c 332#[doc(masked)]
532ac7d7 333#[allow(unused_extern_crates)]
1a4d82fc
JJ
334extern crate libc;
335
a7813a04 336// We always need an unwinder currently for backtraces
ea8adc8c 337#[doc(masked)]
3b2f2976 338#[allow(unused_extern_crates)]
a7813a04
XL
339extern crate unwind;
340
dc9dc135
XL
341// Only needed for now for the `std_detect` module until that crate changes to
342// use `cfg_if::cfg_if!`
343#[macro_use]
344#[cfg(not(test))]
345extern crate cfg_if;
346
c30ab7b3
SL
347// During testing, this crate is not actually the "real" std library, but rather
348// it links to the real std library, which was compiled from this same source
349// code. So any lang items std defines are conditionally excluded (or else they
83c7162d 350// would generate duplicate lang item errors), and any globals it defines are
c30ab7b3
SL
351// _not_ the globals used by "real" std. So this import, defined only during
352// testing gives test-std access to real-std lang items and globals. See #2912
c34b1796 353#[cfg(test)] extern crate std as realstd;
1a4d82fc 354
c30ab7b3
SL
355// The standard macros that are not built-in to the compiler.
356#[macro_use]
357mod macros;
358
359// The Rust prelude
360pub mod prelude;
1a4d82fc 361
2c00a5a8 362// Public module declarations and re-exports
92a42be0 363#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 364pub use core::any;
9fa01778
XL
365#[stable(feature = "simd_arch", since = "1.27.0")]
366#[doc(no_inline)]
367pub use core::arch;
92a42be0 368#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 369pub use core::cell;
92a42be0 370#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 371pub use core::clone;
92a42be0 372#[stable(feature = "rust1", since = "1.0.0")]
c1a9b12d 373pub use core::cmp;
92a42be0 374#[stable(feature = "rust1", since = "1.0.0")]
c34b1796 375pub use core::convert;
92a42be0 376#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 377pub use core::default;
92a42be0 378#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 379pub use core::hash;
92a42be0 380#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 381pub use core::intrinsics;
92a42be0 382#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 383pub use core::iter;
92a42be0 384#[stable(feature = "rust1", since = "1.0.0")]
c1a9b12d 385pub use core::marker;
92a42be0 386#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 387pub use core::mem;
92a42be0 388#[stable(feature = "rust1", since = "1.0.0")]
c1a9b12d 389pub use core::ops;
92a42be0 390#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 391pub use core::ptr;
92a42be0 392#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 393pub use core::raw;
92a42be0 394#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 395pub use core::result;
92a42be0 396#[stable(feature = "rust1", since = "1.0.0")]
1a4d82fc 397pub use core::option;
92a42be0 398#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 399pub use core::isize;
92a42be0 400#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 401pub use core::i8;
92a42be0 402#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 403pub use core::i16;
92a42be0 404#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 405pub use core::i32;
92a42be0 406#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 407pub use core::i64;
0531ce1d 408#[stable(feature = "i128", since = "1.26.0")]
32a655c1 409pub use core::i128;
92a42be0 410#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 411pub use core::usize;
92a42be0 412#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 413pub use core::u8;
92a42be0 414#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 415pub use core::u16;
92a42be0 416#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 417pub use core::u32;
92a42be0 418#[stable(feature = "rust1", since = "1.0.0")]
e9174d1e 419pub use core::u64;
c30ab7b3 420#[stable(feature = "rust1", since = "1.0.0")]
83c7162d
XL
421pub use alloc_crate::boxed;
422#[stable(feature = "rust1", since = "1.0.0")]
423pub use alloc_crate::rc;
c30ab7b3 424#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 425pub use alloc_crate::borrow;
c30ab7b3 426#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 427pub use alloc_crate::fmt;
c30ab7b3 428#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 429pub use alloc_crate::format;
0731742a 430#[stable(feature = "pin", since = "1.33.0")]
0bf4aa26 431pub use core::pin;
c30ab7b3 432#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 433pub use alloc_crate::slice;
c30ab7b3 434#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 435pub use alloc_crate::str;
c30ab7b3 436#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 437pub use alloc_crate::string;
c30ab7b3 438#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 439pub use alloc_crate::vec;
c30ab7b3 440#[stable(feature = "rust1", since = "1.0.0")]
83c7162d 441pub use core::char;
0531ce1d 442#[stable(feature = "i128", since = "1.26.0")]
32a655c1 443pub use core::u128;
83c7162d
XL
444#[stable(feature = "core_hint", since = "1.27.0")]
445pub use core::hint;
532ac7d7
XL
446#[stable(feature = "core_array", since = "1.36.0")]
447pub use core::array;
1a4d82fc 448
c30ab7b3
SL
449pub mod f32;
450pub mod f64;
1a4d82fc
JJ
451
452#[macro_use]
c34b1796 453pub mod thread;
c30ab7b3 454pub mod ascii;
e1599b0c 455pub mod backtrace;
c34b1796 456pub mod collections;
c34b1796 457pub mod env;
c30ab7b3 458pub mod error;
1a4d82fc 459pub mod ffi;
85aaf69f 460pub mod fs;
c34b1796 461pub mod io;
85aaf69f 462pub mod net;
c30ab7b3 463pub mod num;
1a4d82fc 464pub mod os;
9cc50fc6 465pub mod panic;
1a4d82fc 466pub mod path;
85aaf69f 467pub mod process;
c34b1796 468pub mod sync;
1a4d82fc 469pub mod time;
83c7162d 470
48663c56 471#[stable(feature = "futures_api", since = "1.36.0")]
8faf50e0
XL
472pub mod task {
473 //! Types and Traits for working with asynchronous tasks.
474 #[doc(inline)]
48663c56 475 #[stable(feature = "futures_api", since = "1.36.0")]
8faf50e0 476 pub use core::task::*;
8faf50e0
XL
477}
478
48663c56 479#[stable(feature = "futures_api", since = "1.36.0")]
8faf50e0
XL
480pub mod future;
481
c30ab7b3 482// Platform-abstraction modules
c34b1796 483#[macro_use]
c30ab7b3
SL
484mod sys_common;
485mod sys;
1a4d82fc 486
83c7162d
XL
487pub mod alloc;
488
c30ab7b3 489// Private support modules
85aaf69f 490mod panicking;
c30ab7b3
SL
491mod memchr;
492
c30ab7b3
SL
493// The runtime entry point and a few unstable public functions used by the
494// compiler
495pub mod rt;
ff7c6d11 496
9fa01778 497// Pull in the `std_detect` crate directly into libstd. The contents of
416331ca 498// `std_detect` are in a different repository: rust-lang/stdarch.
0531ce1d 499//
9fa01778
XL
500// `std_detect` depends on libstd, but the contents of this module are
501// set up in such a way that directly pulling it here works such that the
502// crate uses the this crate as its libstd.
416331ca 503#[path = "../stdarch/crates/std_detect/src/mod.rs"]
0531ce1d
XL
504#[allow(missing_debug_implementations, missing_docs, dead_code)]
505#[unstable(feature = "stdsimd", issue = "48556")]
0731742a 506#[cfg(not(test))]
9fa01778 507mod std_detect;
0531ce1d 508
9fa01778
XL
509#[doc(hidden)]
510#[unstable(feature = "stdsimd", issue = "48556")]
0731742a 511#[cfg(not(test))]
9fa01778 512pub use std_detect::detect;
9346a6ac 513
416331ca
XL
514// Re-export macros defined in libcore.
515#[stable(feature = "rust1", since = "1.0.0")]
e1599b0c 516#[allow(deprecated, deprecated_in_future)]
416331ca
XL
517pub use core::{
518 // Stable
519 assert_eq,
520 assert_ne,
521 debug_assert_eq,
522 debug_assert_ne,
523 debug_assert,
524 r#try,
525 unimplemented,
526 unreachable,
527 write,
528 writeln,
529 // Unstable
530 todo,
e74abb32 531 matches,
416331ca
XL
532};
533
534// Re-export built-in macros defined through libcore.
416331ca
XL
535#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
536pub use core::{
537 // Stable
538 assert,
539 cfg,
540 column,
541 compile_error,
542 concat,
543 env,
544 file,
545 format_args,
546 include,
547 include_bytes,
548 include_str,
549 line,
550 module_path,
551 option_env,
552 stringify,
553 // Unstable
416331ca
XL
554 asm,
555 concat_idents,
556 format_args_nl,
557 global_asm,
558 log_syntax,
559 trace_macros,
560};
561
c1a9b12d
SL
562// Include a number of private modules that exist solely to provide
563// the rustdoc documentation for primitive types. Using `include!`
564// because rustdoc only looks for these modules at the crate level.
565include!("primitive_docs.rs");
94b46f34
XL
566
567// Include a number of private modules that exist solely to provide
568// the rustdoc documentation for the existing keywords. Using `include!`
569// because rustdoc only looks for these modules at the crate level.
570include!("keyword_docs.rs");