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//! button</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> 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(target_family = "wasm", feature(stdarch_wasm_atomic_wait))]
267#![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
268//
269// Language features:
270// tidy-alphabetical-start
271
272// stabilization was reverted after it hit beta
273#![feature(alloc_error_handler)]
274#![feature(allocator_internals)]
275#![feature(allow_internal_unsafe)]
276#![feature(allow_internal_unstable)]
277#![feature(asm_experimental_arch)]
278#![feature(autodiff)]
279#![feature(cfg_sanitizer_cfi)]
280#![feature(cfg_target_thread_local)]
281#![feature(cfi_encoding)]
282#![feature(char_max_len)]
283#![feature(const_trait_impl)]
284#![feature(core_float_math)]
285#![feature(decl_macro)]
286#![feature(deprecated_suggestion)]
287#![feature(doc_cfg)]
288#![feature(doc_cfg_hide)]
289#![feature(doc_masked)]
290#![feature(doc_notable_trait)]
291#![feature(dropck_eyepatch)]
292#![feature(f16)]
293#![feature(f128)]
294#![feature(ffi_const)]
295#![feature(formatting_options)]
296#![feature(funnel_shifts)]
297#![feature(hash_map_internals)]
298#![feature(hash_map_macro)]
299#![feature(if_let_guard)]
300#![feature(intra_doc_pointers)]
301#![feature(iter_advance_by)]
302#![feature(iter_next_chunk)]
303#![feature(lang_items)]
304#![feature(link_cfg)]
305#![feature(linkage)]
306#![feature(macro_metavar_expr_concat)]
307#![feature(maybe_uninit_fill)]
308#![feature(min_specialization)]
309#![feature(must_not_suspend)]
310#![feature(needs_panic_runtime)]
311#![feature(negative_impls)]
312#![feature(never_type)]
313#![feature(optimize_attribute)]
314#![feature(prelude_import)]
315#![feature(rustc_attrs)]
316#![feature(rustdoc_internals)]
317#![feature(staged_api)]
318#![feature(stmt_expr_attributes)]
319#![feature(strict_provenance_lints)]
320#![feature(thread_local)]
321#![feature(try_blocks)]
322#![feature(try_trait_v2)]
323#![feature(type_alias_impl_trait)]
324// tidy-alphabetical-end
325//
326// Library features (core):
327// tidy-alphabetical-start
328#![feature(bstr)]
329#![feature(bstr_internals)]
330#![feature(cast_maybe_uninit)]
331#![feature(cfg_select)]
332#![feature(char_internals)]
333#![feature(clone_to_uninit)]
334#![feature(const_convert)]
335#![feature(core_intrinsics)]
336#![feature(core_io_borrowed_buf)]
337#![feature(drop_guard)]
338#![feature(duration_constants)]
339#![feature(error_generic_member_access)]
340#![feature(error_iter)]
341#![feature(exact_size_is_empty)]
342#![feature(exclusive_wrapper)]
343#![feature(extend_one)]
344#![feature(float_algebraic)]
345#![feature(float_gamma)]
346#![feature(float_minimum_maximum)]
347#![feature(fmt_internals)]
348#![feature(fn_ptr_trait)]
349#![feature(generic_atomic)]
350#![feature(hasher_prefixfree_extras)]
351#![feature(hashmap_internals)]
352#![feature(hint_must_use)]
353#![feature(int_from_ascii)]
354#![feature(ip)]
355#![feature(lazy_get)]
356#![feature(maybe_uninit_slice)]
357#![feature(maybe_uninit_write_slice)]
358#![feature(panic_can_unwind)]
359#![feature(panic_internals)]
360#![feature(pin_coerce_unsized_trait)]
361#![feature(pointer_is_aligned_to)]
362#![feature(portable_simd)]
363#![feature(ptr_as_uninit)]
364#![feature(ptr_mask)]
365#![feature(random)]
366#![feature(slice_internals)]
367#![feature(slice_ptr_get)]
368#![feature(slice_range)]
369#![feature(slice_split_once)]
370#![feature(std_internals)]
371#![feature(str_internals)]
372#![feature(sync_unsafe_cell)]
373#![feature(temporary_niche_types)]
374#![feature(ub_checks)]
375#![feature(used_with_arg)]
376// tidy-alphabetical-end
377//
378// Library features (alloc):
379// tidy-alphabetical-start
380#![feature(alloc_layout_extra)]
381#![feature(allocator_api)]
382#![feature(get_mut_unchecked)]
383#![feature(map_try_insert)]
384#![feature(new_zeroed_alloc)]
385#![feature(slice_concat_trait)]
386#![feature(thin_box)]
387#![feature(try_reserve_kind)]
388#![feature(try_with_capacity)]
389#![feature(unique_rc_arc)]
390#![feature(vec_into_raw_parts)]
391#![feature(wtf8_internals)]
392// tidy-alphabetical-end
393//
394// Library features (unwind):
395// tidy-alphabetical-start
396#![feature(panic_unwind)]
397// tidy-alphabetical-end
398//
399// Library features (std_detect):
400// tidy-alphabetical-start
401#![feature(stdarch_internal)]
402// tidy-alphabetical-end
403//
404// Only for re-exporting:
405// tidy-alphabetical-start
406#![feature(assert_matches)]
407#![feature(async_iterator)]
408#![feature(c_variadic)]
409#![feature(cfg_accessible)]
410#![feature(cfg_eval)]
411#![feature(concat_bytes)]
412#![feature(const_format_args)]
413#![feature(custom_test_frameworks)]
414#![feature(edition_panic)]
415#![feature(format_args_nl)]
416#![feature(log_syntax)]
417#![feature(test)]
418#![feature(trace_macros)]
419// tidy-alphabetical-end
420//
421// Only used in tests/benchmarks:
422//
423// Only for const-ness:
424// tidy-alphabetical-start
425#![feature(io_const_error)]
426// tidy-alphabetical-end
427//
428#![default_lib_allocator]
429
430// The Rust prelude
431// The compiler expects the prelude definition to be defined before it's use statement.
432pub mod prelude;
433
434// Explicitly import the prelude. The compiler uses this same unstable attribute
435// to import the prelude implicitly when building crates that depend on std.
436#[prelude_import]
437#[allow(unused)]
438use prelude::rust_2024::*;
439
440// Access to Bencher, etc.
441#[cfg(test)]
442extern crate test;
443
444#[allow(unused_imports)] // macros from `alloc` are not used on all platforms
445#[macro_use]
446extern crate alloc as alloc_crate;
447
448// Many compiler tests depend on libc being pulled in by std
449// so include it here even if it's unused.
450#[doc(masked)]
451#[allow(unused_extern_crates)]
452#[cfg(not(all(windows, target_env = "msvc")))]
453extern crate libc;
454
455// We always need an unwinder currently for backtraces
456#[doc(masked)]
457#[allow(unused_extern_crates)]
458extern crate unwind;
459
460// FIXME: #94122 this extern crate definition only exist here to stop
461// miniz_oxide docs leaking into std docs. Find better way to do it.
462// Remove exclusion from tidy platform check when this removed.
463#[doc(masked)]
464#[allow(unused_extern_crates)]
465#[cfg(all(
466 not(all(windows, target_env = "msvc", not(target_vendor = "uwp"))),
467 feature = "miniz_oxide"
468))]
469extern crate miniz_oxide;
470
471// During testing, this crate is not actually the "real" std library, but rather
472// it links to the real std library, which was compiled from this same source
473// code. So any lang items std defines are conditionally excluded (or else they
474// would generate duplicate lang item errors), and any globals it defines are
475// _not_ the globals used by "real" std. So this import, defined only during
476// testing gives test-std access to real-std lang items and globals. See #2912
477#[cfg(test)]
478extern crate std as realstd;
479
480// The standard macros that are not built-in to the compiler.
481#[macro_use]
482mod macros;
483
484// The runtime entry point and a few unstable public functions used by the
485// compiler
486#[macro_use]
487pub mod rt;
488
489#[stable(feature = "rust1", since = "1.0.0")]
490pub use core::any;
491#[stable(feature = "core_array", since = "1.35.0")]
492pub use core::array;
493#[unstable(feature = "async_iterator", issue = "79024")]
494pub use core::async_iter;
495#[stable(feature = "rust1", since = "1.0.0")]
496pub use core::cell;
497#[stable(feature = "rust1", since = "1.0.0")]
498pub use core::char;
499#[stable(feature = "rust1", since = "1.0.0")]
500pub use core::clone;
501#[stable(feature = "rust1", since = "1.0.0")]
502pub use core::cmp;
503#[stable(feature = "rust1", since = "1.0.0")]
504pub use core::convert;
505#[stable(feature = "rust1", since = "1.0.0")]
506pub use core::default;
507#[stable(feature = "futures_api", since = "1.36.0")]
508pub use core::future;
509#[stable(feature = "core_hint", since = "1.27.0")]
510pub use core::hint;
511#[stable(feature = "rust1", since = "1.0.0")]
512#[allow(deprecated, deprecated_in_future)]
513pub use core::i8;
514#[stable(feature = "rust1", since = "1.0.0")]
515#[allow(deprecated, deprecated_in_future)]
516pub use core::i16;
517#[stable(feature = "rust1", since = "1.0.0")]
518#[allow(deprecated, deprecated_in_future)]
519pub use core::i32;
520#[stable(feature = "rust1", since = "1.0.0")]
521#[allow(deprecated, deprecated_in_future)]
522pub use core::i64;
523#[stable(feature = "i128", since = "1.26.0")]
524#[allow(deprecated, deprecated_in_future)]
525pub use core::i128;
526#[stable(feature = "rust1", since = "1.0.0")]
527pub use core::intrinsics;
528#[stable(feature = "rust1", since = "1.0.0")]
529#[allow(deprecated, deprecated_in_future)]
530pub use core::isize;
531#[stable(feature = "rust1", since = "1.0.0")]
532pub use core::iter;
533#[stable(feature = "rust1", since = "1.0.0")]
534pub use core::marker;
535#[stable(feature = "rust1", since = "1.0.0")]
536pub use core::mem;
537#[stable(feature = "rust1", since = "1.0.0")]
538pub use core::ops;
539#[stable(feature = "rust1", since = "1.0.0")]
540pub use core::option;
541#[stable(feature = "pin", since = "1.33.0")]
542pub use core::pin;
543#[stable(feature = "rust1", since = "1.0.0")]
544pub use core::ptr;
545#[unstable(feature = "new_range_api", issue = "125687")]
546pub use core::range;
547#[stable(feature = "rust1", since = "1.0.0")]
548pub use core::result;
549#[stable(feature = "rust1", since = "1.0.0")]
550#[allow(deprecated, deprecated_in_future)]
551pub use core::u8;
552#[stable(feature = "rust1", since = "1.0.0")]
553#[allow(deprecated, deprecated_in_future)]
554pub use core::u16;
555#[stable(feature = "rust1", since = "1.0.0")]
556#[allow(deprecated, deprecated_in_future)]
557pub use core::u32;
558#[stable(feature = "rust1", since = "1.0.0")]
559#[allow(deprecated, deprecated_in_future)]
560pub use core::u64;
561#[stable(feature = "i128", since = "1.26.0")]
562#[allow(deprecated, deprecated_in_future)]
563pub use core::u128;
564#[unstable(feature = "unsafe_binders", issue = "130516")]
565pub use core::unsafe_binder;
566#[stable(feature = "rust1", since = "1.0.0")]
567#[allow(deprecated, deprecated_in_future)]
568pub use core::usize;
569
570#[stable(feature = "rust1", since = "1.0.0")]
571pub use alloc_crate::borrow;
572#[stable(feature = "rust1", since = "1.0.0")]
573pub use alloc_crate::boxed;
574#[stable(feature = "rust1", since = "1.0.0")]
575pub use alloc_crate::fmt;
576#[stable(feature = "rust1", since = "1.0.0")]
577pub use alloc_crate::format;
578#[stable(feature = "rust1", since = "1.0.0")]
579pub use alloc_crate::rc;
580#[stable(feature = "rust1", since = "1.0.0")]
581pub use alloc_crate::slice;
582#[stable(feature = "rust1", since = "1.0.0")]
583pub use alloc_crate::str;
584#[stable(feature = "rust1", since = "1.0.0")]
585pub use alloc_crate::string;
586#[stable(feature = "rust1", since = "1.0.0")]
587pub use alloc_crate::vec;
588
589#[path = "num/f128.rs"]
590pub mod f128;
591#[path = "num/f16.rs"]
592pub mod f16;
593#[path = "num/f32.rs"]
594pub mod f32;
595#[path = "num/f64.rs"]
596pub mod f64;
597
598#[macro_use]
599pub mod thread;
600pub mod ascii;
601pub mod backtrace;
602#[unstable(feature = "bstr", issue = "134915")]
603pub mod bstr;
604pub mod collections;
605pub mod env;
606pub mod error;
607pub mod ffi;
608pub mod fs;
609pub mod hash;
610pub mod io;
611pub mod net;
612pub mod num;
613pub mod os;
614pub mod panic;
615#[unstable(feature = "pattern_type_macro", issue = "123646")]
616pub mod pat;
617pub mod path;
618pub mod process;
619#[unstable(feature = "random", issue = "130703")]
620pub mod random;
621pub mod sync;
622pub mod time;
623
624// Pull in `std_float` crate into std. The contents of
625// `std_float` are in a different repository: rust-lang/portable-simd.
626#[path = "../../portable-simd/crates/std_float/src/lib.rs"]
627#[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn)]
628#[allow(rustdoc::bare_urls)]
629#[unstable(feature = "portable_simd", issue = "86656")]
630mod std_float;
631
632#[unstable(feature = "portable_simd", issue = "86656")]
633pub mod simd {
634 #![doc = include_str!("../../portable-simd/crates/core_simd/src/core_simd_docs.md")]
635
636 #[doc(inline)]
637 pub use core::simd::*;
638
639 #[doc(inline)]
640 pub use crate::std_float::StdFloat;
641}
642
643#[unstable(feature = "autodiff", issue = "124509")]
644/// This module provides support for automatic differentiation.
645pub mod autodiff {
646 /// This macro handles automatic differentiation.
647 pub use core::autodiff::{autodiff_forward, autodiff_reverse};
648}
649
650#[stable(feature = "futures_api", since = "1.36.0")]
651pub mod task {
652 //! Types and Traits for working with asynchronous tasks.
653
654 #[doc(inline)]
655 #[stable(feature = "wake_trait", since = "1.51.0")]
656 pub use alloc::task::*;
657 #[doc(inline)]
658 #[stable(feature = "futures_api", since = "1.36.0")]
659 pub use core::task::*;
660}
661
662#[doc = include_str!("../../stdarch/crates/core_arch/src/core_arch_docs.md")]
663#[stable(feature = "simd_arch", since = "1.27.0")]
664pub mod arch {
665 #[stable(feature = "simd_arch", since = "1.27.0")]
666 // The `no_inline`-attribute is required to make the documentation of all
667 // targets available.
668 // See https://github.com/rust-lang/rust/pull/57808#issuecomment-457390549 for
669 // more information.
670 #[doc(no_inline)] // Note (#82861): required for correct documentation
671 pub use core::arch::*;
672
673 #[stable(feature = "simd_aarch64", since = "1.60.0")]
674 pub use std_detect::is_aarch64_feature_detected;
675 #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
676 pub use std_detect::is_arm_feature_detected;
677 #[unstable(feature = "is_loongarch_feature_detected", issue = "117425")]
678 pub use std_detect::is_loongarch_feature_detected;
679 #[unstable(feature = "is_riscv_feature_detected", issue = "111192")]
680 pub use std_detect::is_riscv_feature_detected;
681 #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
682 pub use std_detect::is_s390x_feature_detected;
683 #[stable(feature = "simd_x86", since = "1.27.0")]
684 pub use std_detect::is_x86_feature_detected;
685 #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
686 pub use std_detect::{is_mips_feature_detected, is_mips64_feature_detected};
687 #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
688 pub use std_detect::{is_powerpc_feature_detected, is_powerpc64_feature_detected};
689}
690
691// This was stabilized in the crate root so we have to keep it there.
692#[stable(feature = "simd_x86", since = "1.27.0")]
693pub use std_detect::is_x86_feature_detected;
694
695// Platform-abstraction modules
696mod sys;
697mod sys_common;
698
699pub mod alloc;
700
701// Private support modules
702mod panicking;
703
704#[path = "../../backtrace/src/lib.rs"]
705#[allow(dead_code, unused_attributes, fuzzy_provenance_casts, unsafe_op_in_unsafe_fn)]
706mod backtrace_rs;
707
708#[unstable(feature = "cfg_select", issue = "115585")]
709pub use core::cfg_select;
710#[unstable(
711 feature = "concat_bytes",
712 issue = "87555",
713 reason = "`concat_bytes` is not stable enough for use and is subject to change"
714)]
715pub use core::concat_bytes;
716#[stable(feature = "matches_macro", since = "1.42.0")]
717#[allow(deprecated, deprecated_in_future)]
718pub use core::matches;
719#[stable(feature = "core_primitive", since = "1.43.0")]
720pub use core::primitive;
721#[stable(feature = "todo_macro", since = "1.40.0")]
722#[allow(deprecated, deprecated_in_future)]
723pub use core::todo;
724// Re-export built-in macros defined through core.
725#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
726pub use core::{
727 assert, assert_matches, cfg, column, compile_error, concat, const_format_args, env, file,
728 format_args, format_args_nl, include, include_bytes, include_str, line, log_syntax,
729 module_path, option_env, stringify, trace_macros,
730};
731// Re-export macros defined in core.
732#[stable(feature = "rust1", since = "1.0.0")]
733#[allow(deprecated, deprecated_in_future)]
734pub use core::{
735 assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, r#try, unimplemented,
736 unreachable, write, writeln,
737};
738
739// Re-export unstable derive macro defined through core.
740#[unstable(feature = "derive_from", issue = "144889")]
741/// Unstable module containing the unstable `From` derive macro.
742pub mod from {
743 #[unstable(feature = "derive_from", issue = "144889")]
744 pub use core::from::From;
745}
746
747// Include a number of private modules that exist solely to provide
748// the rustdoc documentation for primitive types. Using `include!`
749// because rustdoc only looks for these modules at the crate level.
750include!("../../core/src/primitive_docs.rs");
751
752// Include a number of private modules that exist solely to provide
753// the rustdoc documentation for the existing keywords. Using `include!`
754// because rustdoc only looks for these modules at the crate level.
755include!("keyword_docs.rs");
756
757// This is required to avoid an unstable error when `restricted-std` is not
758// enabled. The use of #![feature(restricted_std)] in rustc-std-workspace-std
759// is unconditional, so the unstable feature needs to be defined somewhere.
760#[unstable(feature = "restricted_std", issue = "none")]
761mod __restricted_std_workaround {}
762
763mod sealed {
764 /// This trait being unreachable from outside the crate
765 /// prevents outside implementations of our extension traits.
766 /// This allows adding more trait methods in the future.
767 #[unstable(feature = "sealed", issue = "none")]
768 pub trait Sealed {}
769}
770
771#[cfg(test)]
772#[allow(dead_code)] // Not used in all configurations.
773pub(crate) mod test_helpers;