#
std/
lib.rs

    1//! # The Rust Standard Library
    2//!
    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//!
    10//! `std` is available to all Rust crates by default. Therefore, the
    11//! standard library can be accessed in [`use`] statements through the path
    12//! `std`, as in [`use std::env`].
    13//!
    14//! # How to read this documentation
    15//!
    16//! If you already know the name of what you are looking for, the fastest way to
    17//! find it is to use the <a href="#" onclick="window.searchState.focus();">search
    18//! bar</a> at the top of the page.
    19//!
    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]
    26//!
    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!
    32//!
    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
    35//! development you may want to press the
    36//! "<svg style="width:0.75rem;height:0.75rem" viewBox="0 0 12 12" stroke="currentColor" fill="none"><path d="M2,2l4,4l4,-4M2,6l4,4l4,-4"/></svg>&nbsp;Summary"
    37//! button near the top of the page to collapse it into a more skimmable view.
    38//!
    39//! While you are looking at the top of the page, also notice the
    40//! "Source" link. Rust's API documentation comes with the source
    41//! code and you are encouraged to read it. The standard library source is
    42//! generally high quality and a peek behind the curtains is
    43//! often enlightening.
    44//!
    45//! # What is in the standard library documentation?
    46//!
    47//! First of all, The Rust Standard Library is divided into a number of focused
    48//! modules, [all listed further down this page](#modules). These modules are
    49//! the bedrock upon which all of Rust is forged, and they have mighty names
    50//! like [`std::slice`] and [`std::cmp`]. Modules' documentation typically
    51//! includes an overview of the module along with examples, and are a smart
    52//! place to start familiarizing yourself with the library.
    53//!
    54//! Second, implicit methods on [primitive types] are documented here. This can
    55//! be a source of confusion for two reasons:
    56//!
    57//! 1. While primitives are implemented by the compiler, the standard library
    58//!    implements methods directly on the primitive types (and it is the only
    59//!    library that does so), which are [documented in the section on
    60//!    primitives](#primitives).
    61//! 2. The standard library exports many modules *with the same name as
    62//!    primitive types*. These define additional items related to the primitive
    63//!    type, but not the all-important methods.
    64//!
    65//! So for example there is a [page for the primitive type
    66//! `i32`](primitive::i32) that lists all the methods that can be called on
    67//! 32-bit integers (very useful), and there is a [page for the module
    68//! `std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely
    69//! useful).
    70//!
    71//! Note the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also
    72//! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually
    73//! calls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref
    74//! coercions][deref-coercions].
    75//!
    76//! Third, the standard library defines [The Rust Prelude], a small collection
    77//! of items - mostly traits - that are imported into every module of every
    78//! crate. The traits in the prelude are pervasive, making the prelude
    79//! documentation a good entry point to learning about the library.
    80//!
    81//! And finally, the standard library exports a number of standard macros, and
    82//! [lists them on this page](#macros) (technically, not all of the standard
    83//! macros are defined by the standard library - some are defined by the
    84//! compiler - but they are documented here the same). Like the prelude, the
    85//! standard macros are imported by default into all crates.
    86//!
    87//! # Contributing changes to the documentation
    88//!
    89//! Check out the Rust contribution guidelines [here](
    90//! https://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).
    91//! The source for this documentation can be found on
    92//! [GitHub](https://github.com/rust-lang/rust) in the 'library/std/' directory.
    93//! To contribute changes, make sure you read the guidelines first, then submit
    94//! pull-requests for your suggested changes.
    95//!
    96//! Contributions are appreciated! If you see a part of the docs that can be
    97//! improved, submit a PR, or chat with us first on [Discord][rust-discord]
    98//! #docs.
    99//!
    100//! # A Tour of The Rust Standard Library
    101//!
    102//! The rest of this crate documentation is dedicated to pointing out notable
    103//! features of The Rust Standard Library.
    104//!
    105//! ## Containers and collections
    106//!
    107//! The [`option`] and [`result`] modules define optional and error-handling
    108//! types, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines
    109//! Rust's iterator trait, [`Iterator`], which works with the [`for`] loop to
    110//! access collections.
    111//!
    112//! The standard library exposes three common ways to deal with contiguous
    113//! regions of memory:
    114//!
    115//! * [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.
    116//! * [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.
    117//! * [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous
    118//!   storage, whether heap-allocated or not.
    119//!
    120//! Slices can only be handled through some kind of *pointer*, and as such come
    121//! in many flavors such as:
    122//!
    123//! * `&[T]` - *shared slice*
    124//! * `&mut [T]` - *mutable slice*
    125//! * [`Box<[T]>`][owned slice] - *owned slice*
    126//!
    127//! [`str`], a UTF-8 string slice, is a primitive type, and the standard library
    128//! defines many methods for it. Rust [`str`]s are typically accessed as
    129//! immutable references: `&str`. Use the owned [`String`] for building and
    130//! mutating strings.
    131//!
    132//! For converting to strings use the [`format!`] macro, and for converting from
    133//! strings use the [`FromStr`] trait.
    134//!
    135//! Data may be shared by placing it in a reference-counted box or the [`Rc`]
    136//! type, and if further contained in a [`Cell`] or [`RefCell`], may be mutated
    137//! as well as shared. Likewise, in a concurrent setting it is common to pair an
    138//! atomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same
    139//! effect.
    140//!
    141//! The [`collections`] module defines maps, sets, linked lists and other
    142//! typical collection types, including the common [`HashMap<K, V>`].
    143//!
    144//! ## Platform abstractions and I/O
    145//!
    146//! Besides basic data types, the standard library is largely concerned with
    147//! abstracting over differences in common platforms, most notably Windows and
    148//! Unix derivatives.
    149//!
    150//! Common types of I/O, including [files], [TCP], and [UDP], are defined in
    151//! the [`io`], [`fs`], and [`net`] modules.
    152//!
    153//! The [`thread`] module contains Rust's threading abstractions. [`sync`]
    154//! contains further primitive shared memory types, including [`atomic`], [`mpmc`] and
    155//! [`mpsc`], which contains the channel types for message passing.
    156//!
    157//! # Use before and after `main()`
    158//!
    159//! Many parts of the standard library are expected to work before and after `main()`;
    160//! but this is not guaranteed or ensured by tests. It is recommended that you write your own tests
    161//! and run them on each platform you wish to support.
    162//! This means that use of `std` before/after main, especially of features that interact with the
    163//! OS or global state, is exempted from stability and portability guarantees and instead only
    164//! provided on a best-effort basis. Nevertheless bug reports are appreciated.
    165//!
    166//! On the other hand `core` and `alloc` are most likely to work in such environments with
    167//! the caveat that any hookable behavior such as panics, oom handling or allocators will also
    168//! depend on the compatibility of the hooks.
    169//!
    170//! Some features may also behave differently outside main, e.g. stdio could become unbuffered,
    171//! some panics might turn into aborts, backtraces might not get symbolicated or similar.
    172//!
    173//! Non-exhaustive list of known limitations:
    174//!
    175//! - after-main use of thread-locals, which also affects additional features:
    176//!   - [`thread::current()`]
    177//! - under UNIX, before main, file descriptors 0, 1, and 2 may be unchanged
    178//!   (they are guaranteed to be open during main,
    179//!    and are opened to /dev/null O_RDWR if they weren't open on program start)
    180//!
    181//!
    182//! [I/O]: io
    183//! [`MIN`]: i32::MIN
    184//! [`MAX`]: i32::MAX
    185//! [page for the module `std::i32`]: crate::i32
    186//! [TCP]: net::TcpStream
    187//! [The Rust Prelude]: prelude
    188//! [UDP]: net::UdpSocket
    189//! [`Arc`]: sync::Arc
    190//! [owned slice]: boxed
    191//! [`Cell`]: cell::Cell
    192//! [`FromStr`]: str::FromStr
    193//! [`HashMap<K, V>`]: collections::HashMap
    194//! [`Mutex`]: sync::Mutex
    195//! [`Option<T>`]: option::Option
    196//! [`Rc`]: rc::Rc
    197//! [`RefCell`]: cell::RefCell
    198//! [`Result<T, E>`]: result::Result
    199//! [`Vec<T>`]: vec::Vec
    200//! [`atomic`]: sync::atomic
    201//! [`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
    202//! [`str`]: prim@str
    203//! [`mpmc`]: sync::mpmc
    204//! [`mpsc`]: sync::mpsc
    205//! [`std::cmp`]: cmp
    206//! [`std::slice`]: mod@slice
    207//! [`use std::env`]: env/index.html
    208//! [`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html
    209//! [crates.io]: https://crates.io
    210//! [deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods
    211//! [files]: fs::File
    212//! [multithreading]: thread
    213//! [other]: #what-is-in-the-standard-library-documentation
    214//! [primitive types]: ../book/ch03-02-data-types.html
    215//! [rust-discord]: https://discord.gg/rust-lang
    216//! [array]: prim@array
    217//! [slice]: prim@slice
    218
    219#![cfg_attr(not(restricted_std), stable(feature = "rust1", since = "1.0.0"))]
    220#![cfg_attr(
    221    restricted_std,
    222    unstable(
    223        feature = "restricted_std",
    224        issue = "none",
    225        reason = "You have attempted to use a standard library built for a platform that it doesn't \
    226            know how to support. Consider building it for a known environment, disabling it with \
    227            `#![no_std]` or overriding this warning by enabling this feature."
    228    )
    229)]
    230#![rustc_preserve_ub_checks]
    231#![doc(
    232    html_playground_url = "https://play.rust-lang.org/",
    233    issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
    234    test(no_crate_inject, attr(deny(warnings))),
    235    test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
    236)]
    237#![doc(rust_logo)]
    238#![doc(cfg_hide(not(test), no_global_oom_handling, not(no_global_oom_handling)))]
    239// Don't link to std. We are std.
    240#![no_std]
    241// Tell the compiler to link to either panic_abort or panic_unwind
    242#![needs_panic_runtime]
    243//
    244// Lints:
    245#![warn(deprecated_in_future)]
    246#![warn(missing_docs)]
    247#![warn(missing_debug_implementations)]
    248#![allow(explicit_outlives_requirements)]
    249#![allow(unused_lifetimes)]
    250#![allow(internal_features)]
    251#![deny(fuzzy_provenance_casts)]
    252#![deny(unsafe_op_in_unsafe_fn)]
    253#![allow(rustdoc::redundant_explicit_links)]
    254#![warn(rustdoc::unescaped_backticks)]
    255// Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`
    256#![deny(ffi_unwind_calls)]
    257// std may use features in a platform-specific way
    258#![allow(unused_features)]
    259//
    260// Features:
    261#![cfg_attr(test, feature(internal_output_capture, print_internals, update_panic_count, rt))]
    262#![cfg_attr(
    263    all(target_vendor = "fortanix", target_env = "sgx"),
    264    feature(slice_index_methods, coerce_unsized, sgx_platform)
    265)]
    266#![cfg_attr(any(windows, target_os = "uefi"), feature(round_char_boundary))]
    267#![cfg_attr(target_family = "wasm", feature(stdarch_wasm_atomic_wait))]
    268#![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
    269//
    270// Language features:
    271// tidy-alphabetical-start
    272
    273// stabilization was reverted after it hit beta
    274#![feature(alloc_error_handler)]
    275#![feature(allocator_internals)]
    276#![feature(allow_internal_unsafe)]
    277#![feature(allow_internal_unstable)]
    278#![feature(asm_experimental_arch)]
    279#![feature(autodiff)]
    280#![feature(cfg_sanitizer_cfi)]
    281#![feature(cfg_target_thread_local)]
    282#![feature(cfi_encoding)]
    283#![feature(char_max_len)]
    284#![feature(const_trait_impl)]
    285#![feature(core_float_math)]
    286#![feature(decl_macro)]
    287#![feature(deprecated_suggestion)]
    288#![feature(derive_const)]
    289#![feature(doc_cfg)]
    290#![feature(doc_cfg_hide)]
    291#![feature(doc_masked)]
    292#![feature(doc_notable_trait)]
    293#![feature(dropck_eyepatch)]
    294#![feature(extended_varargs_abi_support)]
    295#![feature(f16)]
    296#![feature(f128)]
    297#![feature(ffi_const)]
    298#![feature(formatting_options)]
    299#![feature(hash_map_internals)]
    300#![feature(hash_map_macro)]
    301#![feature(if_let_guard)]
    302#![feature(intra_doc_pointers)]
    303#![feature(iter_advance_by)]
    304#![feature(iter_next_chunk)]
    305#![feature(lang_items)]
    306#![feature(link_cfg)]
    307#![feature(linkage)]
    308#![feature(macro_metavar_expr_concat)]
    309#![feature(maybe_uninit_fill)]
    310#![feature(min_specialization)]
    311#![feature(must_not_suspend)]
    312#![feature(needs_panic_runtime)]
    313#![feature(negative_impls)]
    314#![feature(never_type)]
    315#![feature(optimize_attribute)]
    316#![feature(prelude_import)]
    317#![feature(rustc_attrs)]
    318#![feature(rustdoc_internals)]
    319#![feature(staged_api)]
    320#![feature(stmt_expr_attributes)]
    321#![feature(strict_provenance_lints)]
    322#![feature(thread_local)]
    323#![feature(try_blocks)]
    324#![feature(try_trait_v2)]
    325#![feature(type_alias_impl_trait)]
    326// tidy-alphabetical-end
    327//
    328// Library features (core):
    329// tidy-alphabetical-start
    330#![feature(bstr)]
    331#![feature(bstr_internals)]
    332#![feature(cast_maybe_uninit)]
    333#![feature(char_internals)]
    334#![feature(clone_to_uninit)]
    335#![feature(const_cmp)]
    336#![feature(const_ops)]
    337#![feature(const_option_ops)]
    338#![feature(const_try)]
    339#![feature(core_intrinsics)]
    340#![feature(core_io_borrowed_buf)]
    341#![feature(drop_guard)]
    342#![feature(duration_constants)]
    343#![feature(error_generic_member_access)]
    344#![feature(error_iter)]
    345#![feature(exact_size_is_empty)]
    346#![feature(exclusive_wrapper)]
    347#![feature(extend_one)]
    348#![feature(float_algebraic)]
    349#![feature(float_gamma)]
    350#![feature(float_minimum_maximum)]
    351#![feature(fmt_internals)]
    352#![feature(generic_atomic)]
    353#![feature(hasher_prefixfree_extras)]
    354#![feature(hashmap_internals)]
    355#![feature(hint_must_use)]
    356#![feature(ip)]
    357#![feature(lazy_get)]
    358#![feature(maybe_uninit_slice)]
    359#![feature(maybe_uninit_write_slice)]
    360#![feature(panic_can_unwind)]
    361#![feature(panic_internals)]
    362#![feature(pin_coerce_unsized_trait)]
    363#![feature(pointer_is_aligned_to)]
    364#![feature(portable_simd)]
    365#![feature(ptr_as_uninit)]
    366#![feature(ptr_mask)]
    367#![feature(random)]
    368#![feature(slice_internals)]
    369#![feature(slice_ptr_get)]
    370#![feature(slice_range)]
    371#![feature(std_internals)]
    372#![feature(str_internals)]
    373#![feature(strict_provenance_atomic_ptr)]
    374#![feature(sync_unsafe_cell)]
    375#![feature(temporary_niche_types)]
    376#![feature(ub_checks)]
    377#![feature(used_with_arg)]
    378// tidy-alphabetical-end
    379//
    380// Library features (alloc):
    381// tidy-alphabetical-start
    382#![feature(alloc_layout_extra)]
    383#![feature(allocator_api)]
    384#![feature(get_mut_unchecked)]
    385#![feature(map_try_insert)]
    386#![feature(new_zeroed_alloc)]
    387#![feature(slice_concat_trait)]
    388#![feature(thin_box)]
    389#![feature(try_reserve_kind)]
    390#![feature(try_with_capacity)]
    391#![feature(unique_rc_arc)]
    392#![feature(vec_into_raw_parts)]
    393// tidy-alphabetical-end
    394//
    395// Library features (unwind):
    396// tidy-alphabetical-start
    397#![feature(panic_unwind)]
    398// tidy-alphabetical-end
    399//
    400// Library features (std_detect):
    401// tidy-alphabetical-start
    402#![feature(stdarch_internal)]
    403// tidy-alphabetical-end
    404//
    405// Only for re-exporting:
    406// tidy-alphabetical-start
    407#![feature(assert_matches)]
    408#![feature(async_iterator)]
    409#![feature(c_variadic)]
    410#![feature(cfg_accessible)]
    411#![feature(cfg_eval)]
    412#![feature(concat_bytes)]
    413#![feature(const_format_args)]
    414#![feature(custom_test_frameworks)]
    415#![feature(edition_panic)]
    416#![feature(format_args_nl)]
    417#![feature(log_syntax)]
    418#![feature(test)]
    419#![feature(trace_macros)]
    420// tidy-alphabetical-end
    421//
    422// Only used in tests/benchmarks:
    423//
    424// Only for const-ness:
    425// tidy-alphabetical-start
    426#![feature(io_const_error)]
    427// tidy-alphabetical-end
    428//
    429#![default_lib_allocator]
    430
    431// The Rust prelude
    432// The compiler expects the prelude definition to be defined before it's use statement.
    433pub mod prelude;
    434
    435// Explicitly import the prelude. The compiler uses this same unstable attribute
    436// to import the prelude implicitly when building crates that depend on std.
    437#[prelude_import]
    438#[allow(unused)]
    439use prelude::rust_2024::*;
    440
    441// Access to Bencher, etc.
    442#[cfg(test)]
    443extern crate test;
    444
    445#[allow(unused_imports)] // macros from `alloc` are not used on all platforms
    446#[macro_use]
    447extern crate alloc as alloc_crate;
    448
    449// Many compiler tests depend on libc being pulled in by std
    450// so include it here even if it's unused.
    451#[doc(masked)]
    452#[allow(unused_extern_crates)]
    453#[cfg(not(all(windows, target_env = "msvc")))]
    454extern crate libc;
    455
    456// We always need an unwinder currently for backtraces
    457#[doc(masked)]
    458#[allow(unused_extern_crates)]
    459extern crate unwind;
    460
    461// FIXME: #94122 this extern crate definition only exist here to stop
    462// miniz_oxide docs leaking into std docs. Find better way to do it.
    463// Remove exclusion from tidy platform check when this removed.
    464#[doc(masked)]
    465#[allow(unused_extern_crates)]
    466#[cfg(all(
    467    not(all(windows, target_env = "msvc", not(target_vendor = "uwp"))),
    468    feature = "miniz_oxide"
    469))]
    470extern crate miniz_oxide;
    471
    472// During testing, this crate is not actually the "real" std library, but rather
    473// it links to the real std library, which was compiled from this same source
    474// code. So any lang items std defines are conditionally excluded (or else they
    475// would generate duplicate lang item errors), and any globals it defines are
    476// _not_ the globals used by "real" std. So this import, defined only during
    477// testing gives test-std access to real-std lang items and globals. See #2912
    478#[cfg(test)]
    479extern crate std as realstd;
    480
    481// The standard macros that are not built-in to the compiler.
    482#[macro_use]
    483mod macros;
    484
    485// The runtime entry point and a few unstable public functions used by the
    486// compiler
    487#[macro_use]
    488pub mod rt;
    489
    490#[stable(feature = "rust1", since = "1.0.0")]
    491pub use core::any;
    492#[stable(feature = "core_array", since = "1.35.0")]
    493pub use core::array;
    494#[unstable(feature = "async_iterator", issue = "79024")]
    495pub use core::async_iter;
    496#[stable(feature = "rust1", since = "1.0.0")]
    497pub use core::cell;
    498#[stable(feature = "rust1", since = "1.0.0")]
    499pub use core::char;
    500#[stable(feature = "rust1", since = "1.0.0")]
    501pub use core::clone;
    502#[stable(feature = "rust1", since = "1.0.0")]
    503pub use core::cmp;
    504#[stable(feature = "rust1", since = "1.0.0")]
    505pub use core::convert;
    506#[stable(feature = "rust1", since = "1.0.0")]
    507pub use core::default;
    508#[stable(feature = "futures_api", since = "1.36.0")]
    509pub use core::future;
    510#[stable(feature = "core_hint", since = "1.27.0")]
    511pub use core::hint;
    512#[stable(feature = "rust1", since = "1.0.0")]
    513#[allow(deprecated, deprecated_in_future)]
    514pub use core::i8;
    515#[stable(feature = "rust1", since = "1.0.0")]
    516#[allow(deprecated, deprecated_in_future)]
    517pub use core::i16;
    518#[stable(feature = "rust1", since = "1.0.0")]
    519#[allow(deprecated, deprecated_in_future)]
    520pub use core::i32;
    521#[stable(feature = "rust1", since = "1.0.0")]
    522#[allow(deprecated, deprecated_in_future)]
    523pub use core::i64;
    524#[stable(feature = "i128", since = "1.26.0")]
    525#[allow(deprecated, deprecated_in_future)]
    526pub use core::i128;
    527#[stable(feature = "rust1", since = "1.0.0")]
    528pub use core::intrinsics;
    529#[stable(feature = "rust1", since = "1.0.0")]
    530#[allow(deprecated, deprecated_in_future)]
    531pub use core::isize;
    532#[stable(feature = "rust1", since = "1.0.0")]
    533pub use core::iter;
    534#[stable(feature = "rust1", since = "1.0.0")]
    535pub use core::marker;
    536#[stable(feature = "rust1", since = "1.0.0")]
    537pub use core::mem;
    538#[stable(feature = "rust1", since = "1.0.0")]
    539pub use core::ops;
    540#[stable(feature = "rust1", since = "1.0.0")]
    541pub use core::option;
    542#[stable(feature = "pin", since = "1.33.0")]
    543pub use core::pin;
    544#[stable(feature = "rust1", since = "1.0.0")]
    545pub use core::ptr;
    546#[unstable(feature = "new_range_api", issue = "125687")]
    547pub use core::range;
    548#[stable(feature = "rust1", since = "1.0.0")]
    549pub use core::result;
    550#[stable(feature = "rust1", since = "1.0.0")]
    551#[allow(deprecated, deprecated_in_future)]
    552pub use core::u8;
    553#[stable(feature = "rust1", since = "1.0.0")]
    554#[allow(deprecated, deprecated_in_future)]
    555pub use core::u16;
    556#[stable(feature = "rust1", since = "1.0.0")]
    557#[allow(deprecated, deprecated_in_future)]
    558pub use core::u32;
    559#[stable(feature = "rust1", since = "1.0.0")]
    560#[allow(deprecated, deprecated_in_future)]
    561pub use core::u64;
    562#[stable(feature = "i128", since = "1.26.0")]
    563#[allow(deprecated, deprecated_in_future)]
    564pub use core::u128;
    565#[unstable(feature = "unsafe_binders", issue = "130516")]
    566pub use core::unsafe_binder;
    567#[stable(feature = "rust1", since = "1.0.0")]
    568#[allow(deprecated, deprecated_in_future)]
    569pub use core::usize;
    570
    571#[stable(feature = "rust1", since = "1.0.0")]
    572pub use alloc_crate::borrow;
    573#[stable(feature = "rust1", since = "1.0.0")]
    574pub use alloc_crate::boxed;
    575#[stable(feature = "rust1", since = "1.0.0")]
    576pub use alloc_crate::fmt;
    577#[stable(feature = "rust1", since = "1.0.0")]
    578pub use alloc_crate::format;
    579#[stable(feature = "rust1", since = "1.0.0")]
    580pub use alloc_crate::rc;
    581#[stable(feature = "rust1", since = "1.0.0")]
    582pub use alloc_crate::slice;
    583#[stable(feature = "rust1", since = "1.0.0")]
    584pub use alloc_crate::str;
    585#[stable(feature = "rust1", since = "1.0.0")]
    586pub use alloc_crate::string;
    587#[stable(feature = "rust1", since = "1.0.0")]
    588pub use alloc_crate::vec;
    589
    590#[path = "num/f128.rs"]
    591pub mod f128;
    592#[path = "num/f16.rs"]
    593pub mod f16;
    594#[path = "num/f32.rs"]
    595pub mod f32;
    596#[path = "num/f64.rs"]
    597pub mod f64;
    598
    599#[macro_use]
    600pub mod thread;
    601pub mod ascii;
    602pub mod backtrace;
    603#[unstable(feature = "bstr", issue = "134915")]
    604pub mod bstr;
    605pub mod collections;
    606pub mod env;
    607pub mod error;
    608pub mod ffi;
    609pub mod fs;
    610pub mod hash;
    611pub mod io;
    612pub mod net;
    613pub mod num;
    614pub mod os;
    615pub mod panic;
    616#[unstable(feature = "pattern_type_macro", issue = "123646")]
    617pub mod pat;
    618pub mod path;
    619pub mod process;
    620#[unstable(feature = "random", issue = "130703")]
    621pub mod random;
    622pub mod sync;
    623pub mod time;
    624
    625// Pull in `std_float` crate  into std. The contents of
    626// `std_float` are in a different repository: rust-lang/portable-simd.
    627#[path = "../../portable-simd/crates/std_float/src/lib.rs"]
    628#[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn)]
    629#[allow(rustdoc::bare_urls)]
    630#[unstable(feature = "portable_simd", issue = "86656")]
    631mod std_float;
    632
    633#[unstable(feature = "portable_simd", issue = "86656")]
    634pub mod simd {
    635    #![doc = include_str!("../../portable-simd/crates/core_simd/src/core_simd_docs.md")]
    636
    637    #[doc(inline)]
    638    pub use core::simd::*;
    639
    640    #[doc(inline)]
    641    pub use crate::std_float::StdFloat;
    642}
    643
    644#[unstable(feature = "autodiff", issue = "124509")]
    645/// This module provides support for automatic differentiation.
    646pub mod autodiff {
    647    /// This macro handles automatic differentiation.
    648    pub use core::autodiff::{autodiff_forward, autodiff_reverse};
    649}
    650
    651#[stable(feature = "futures_api", since = "1.36.0")]
    652pub mod task {
    653    //! Types and Traits for working with asynchronous tasks.
    654
    655    #[doc(inline)]
    656    #[stable(feature = "wake_trait", since = "1.51.0")]
    657    pub use alloc::task::*;
    658    #[doc(inline)]
    659    #[stable(feature = "futures_api", since = "1.36.0")]
    660    pub use core::task::*;
    661}
    662
    663#[doc = include_str!("../../stdarch/crates/core_arch/src/core_arch_docs.md")]
    664#[stable(feature = "simd_arch", since = "1.27.0")]
    665pub mod arch {
    666    #[stable(feature = "simd_arch", since = "1.27.0")]
    667    // The `no_inline`-attribute is required to make the documentation of all
    668    // targets available.
    669    // See https://github.com/rust-lang/rust/pull/57808#issuecomment-457390549 for
    670    // more information.
    671    #[doc(no_inline)] // Note (#82861): required for correct documentation
    672    pub use core::arch::*;
    673
    674    #[stable(feature = "simd_aarch64", since = "1.60.0")]
    675    pub use std_detect::is_aarch64_feature_detected;
    676    #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
    677    pub use std_detect::is_arm_feature_detected;
    678    #[unstable(feature = "is_loongarch_feature_detected", issue = "117425")]
    679    pub use std_detect::is_loongarch_feature_detected;
    680    #[unstable(feature = "is_riscv_feature_detected", issue = "111192")]
    681    pub use std_detect::is_riscv_feature_detected;
    682    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
    683    pub use std_detect::is_s390x_feature_detected;
    684    #[stable(feature = "simd_x86", since = "1.27.0")]
    685    pub use std_detect::is_x86_feature_detected;
    686    #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
    687    pub use std_detect::{is_mips_feature_detected, is_mips64_feature_detected};
    688    #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
    689    pub use std_detect::{is_powerpc_feature_detected, is_powerpc64_feature_detected};
    690}
    691
    692// This was stabilized in the crate root so we have to keep it there.
    693#[stable(feature = "simd_x86", since = "1.27.0")]
    694pub use std_detect::is_x86_feature_detected;
    695
    696// Platform-abstraction modules
    697mod sys;
    698mod sys_common;
    699
    700pub mod alloc;
    701
    702// Private support modules
    703mod panicking;
    704
    705#[path = "../../backtrace/src/lib.rs"]
    706#[allow(dead_code, unused_attributes, fuzzy_provenance_casts, unsafe_op_in_unsafe_fn)]
    707mod backtrace_rs;
    708
    709#[unstable(feature = "cfg_select", issue = "115585")]
    710pub use core::cfg_select;
    711#[unstable(
    712    feature = "concat_bytes",
    713    issue = "87555",
    714    reason = "`concat_bytes` is not stable enough for use and is subject to change"
    715)]
    716pub use core::concat_bytes;
    717#[stable(feature = "matches_macro", since = "1.42.0")]
    718#[allow(deprecated, deprecated_in_future)]
    719pub use core::matches;
    720#[stable(feature = "core_primitive", since = "1.43.0")]
    721pub use core::primitive;
    722#[stable(feature = "todo_macro", since = "1.40.0")]
    723#[allow(deprecated, deprecated_in_future)]
    724pub use core::todo;
    725// Re-export built-in macros defined through core.
    726#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
    727pub use core::{
    728    assert, assert_matches, cfg, column, compile_error, concat, const_format_args, env, file,
    729    format_args, format_args_nl, include, include_bytes, include_str, line, log_syntax,
    730    module_path, option_env, stringify, trace_macros,
    731};
    732// Re-export macros defined in core.
    733#[stable(feature = "rust1", since = "1.0.0")]
    734#[allow(deprecated, deprecated_in_future)]
    735pub use core::{
    736    assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, r#try, unimplemented,
    737    unreachable, write, writeln,
    738};
    739
    740// Include a number of private modules that exist solely to provide
    741// the rustdoc documentation for primitive types. Using `include!`
    742// because rustdoc only looks for these modules at the crate level.
    743include!("../../core/src/primitive_docs.rs");
    744
    745// Include a number of private modules that exist solely to provide
    746// the rustdoc documentation for the existing keywords. Using `include!`
    747// because rustdoc only looks for these modules at the crate level.
    748include!("keyword_docs.rs");
    749
    750// This is required to avoid an unstable error when `restricted-std` is not
    751// enabled. The use of #![feature(restricted_std)] in rustc-std-workspace-std
    752// is unconditional, so the unstable feature needs to be defined somewhere.
    753#[unstable(feature = "restricted_std", issue = "none")]
    754mod __restricted_std_workaround {}
    755
    756mod sealed {
    757    /// This trait being unreachable from outside the crate
    758    /// prevents outside implementations of our extension traits.
    759    /// This allows adding more trait methods in the future.
    760    #[unstable(feature = "sealed", issue = "none")]
    761    pub trait Sealed {}
    762}
    763
    764#[cfg(test)]
    765#[allow(dead_code)] // Not used in all configurations.
    766pub(crate) mod test_helpers;