1 //! # The Rust Standard Library
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].
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`].
14 //! # How to read this documentation
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.
20 //! Otherwise, you may want to jump to one of these useful sections:
22 //! * [`std::*` modules](#modules)
23 //! * [Primitive types](#primitives)
24 //! * [Standard macros](#macros)
25 //! * [The Rust Prelude]
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!
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 `[-]` button near the top of the
36 //! page to collapse it into a more skimmable view.
38 //! While you are looking at that `[-]` button also notice the `source`
39 //! link. 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.
43 //! # What is in the standard library documentation?
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.
52 //! Second, implicit methods on [primitive types] are documented here. This can
53 //! be a source of confusion for two reasons:
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.
63 //! So for example there is a [page for the primitive type
64 //! `i32`](primitive::i32) 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`] that documents the constant values [`MIN`] and [`MAX`] (rarely
69 //! Note the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also
70 //! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually
71 //! calls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref
72 //! coercions][deref-coercions].
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
77 //! documentation a good entry point to learning about the library.
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.
85 //! # Contributing changes to the documentation
87 //! Check out the rust contribution guidelines [here](
88 //! https://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).
89 //! The source for this documentation can be found on
90 //! [GitHub](https://github.com/rust-lang/rust).
91 //! To contribute changes, make sure you read the guidelines first, then submit
92 //! pull-requests for your suggested changes.
94 //! Contributions are appreciated! If you see a part of the docs that can be
95 //! improved, submit a PR, or chat with us first on [Discord][rust-discord]
98 //! # A Tour of The Rust Standard Library
100 //! The rest of this crate documentation is dedicated to pointing out notable
101 //! features of The Rust Standard Library.
103 //! ## Containers and collections
105 //! The [`option`] and [`result`] modules define optional and error-handling
106 //! types, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines
107 //! Rust's iterator trait, [`Iterator`], which works with the [`for`] loop to
108 //! access collections.
110 //! The standard library exposes three common ways to deal with contiguous
111 //! regions of memory:
113 //! * [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.
114 //! * [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.
115 //! * [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous
116 //! storage, whether heap-allocated or not.
118 //! Slices can only be handled through some kind of *pointer*, and as such come
119 //! in many flavors such as:
121 //! * `&[T]` - *shared slice*
122 //! * `&mut [T]` - *mutable slice*
123 //! * [`Box<[T]>`][owned slice] - *owned slice*
125 //! [`str`], a UTF-8 string slice, is a primitive type, and the standard library
126 //! defines many methods for it. Rust [`str`]s are typically accessed as
127 //! immutable references: `&str`. Use the owned [`String`] for building and
128 //! mutating strings.
130 //! For converting to strings use the [`format!`] macro, and for converting from
131 //! strings use the [`FromStr`] trait.
133 //! Data may be shared by placing it in a reference-counted box or the [`Rc`]
134 //! type, and if further contained in a [`Cell`] or [`RefCell`], may be mutated
135 //! as well as shared. Likewise, in a concurrent setting it is common to pair an
136 //! atomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same
139 //! The [`collections`] module defines maps, sets, linked lists and other
140 //! typical collection types, including the common [`HashMap<K, V>`].
142 //! ## Platform abstractions and I/O
144 //! Besides basic data types, the standard library is largely concerned with
145 //! abstracting over differences in common platforms, most notably Windows and
146 //! Unix derivatives.
148 //! Common types of I/O, including [files], [TCP], and [UDP], are defined in
149 //! the [`io`], [`fs`], and [`net`] modules.
151 //! The [`thread`] module contains Rust's threading abstractions. [`sync`]
152 //! contains further primitive shared memory types, including [`atomic`] and
153 //! [`mpsc`], which contains the channel types for message passing.
156 //! [`MIN`]: i32::MIN
157 //! [`MAX`]: i32::MAX
158 //! [page for the module `std::i32`]: crate::i32
159 //! [TCP]: net::TcpStream
160 //! [The Rust Prelude]: prelude
161 //! [UDP]: net::UdpSocket
162 //! [`Arc`]: sync::Arc
163 //! [owned slice]: boxed
164 //! [`Cell`]: cell::Cell
165 //! [`FromStr`]: str::FromStr
166 //! [`HashMap<K, V>`]: collections::HashMap
167 //! [`Mutex`]: sync::Mutex
168 //! [`Option<T>`]: option::Option
170 //! [`RefCell`]: cell::RefCell
171 //! [`Result<T, E>`]: result::Result
172 //! [`Vec<T>`]: vec::Vec
173 //! [`atomic`]: sync::atomic
174 //! [`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
175 //! [`str`]: prim@str
176 //! [`mpsc`]: sync::mpsc
177 //! [`std::cmp`]: cmp
178 //! [`std::slice`]: mod@slice
179 //! [`use std::env`]: env/index.html
180 //! [`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html
181 //! [crates.io]: https://crates.io
182 //! [deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods
183 //! [files]: fs::File
184 //! [multithreading]: thread
185 //! [other]: #what-is-in-the-standard-library-documentation
186 //! [primitive types]: ../book/ch03-02-data-types.html
187 //! [rust-discord]: https://discord.gg/rust-lang
188 //! [array]: prim@array
189 //! [slice]: prim@slice
191 #![cfg_attr(not(feature = "restricted-std"), stable(feature = "rust1", since = "1.0.0"))]
192 #![cfg_attr(feature = "restricted-std", unstable(feature = "restricted_std", issue = "none"))]
194 html_playground_url
= "https://play.rust-lang.org/",
195 issue_tracker_base_url
= "https://github.com/rust-lang/rust/issues/",
196 test(no_crate_inject
, attr(deny(warnings
))),
197 test(attr(allow(dead_code
, deprecated
, unused_variables
, unused_mut
)))
201 not(any(test
, bootstrap
)),
202 no_global_oom_handling
,
203 not(no_global_oom_handling
)
205 // To run std tests without x.py without ending up with two copies of std, Miri needs to be
206 // able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
207 // rustc itself never sets the feature, so this line has no affect there.
208 #![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
209 // miri-test-libstd also prefers to make std use the sysroot versions of the dependencies.
210 #![cfg_attr(feature = "miri-test-libstd", feature(rustc_private))]
211 // Don't link to std. We are std.
213 // Tell the compiler to link to either panic_abort or panic_unwind
214 #![needs_panic_runtime]
217 #![warn(deprecated_in_future)]
218 #![warn(missing_docs)]
219 #![warn(missing_debug_implementations)]
220 #![allow(explicit_outlives_requirements)]
221 #![allow(unused_lifetimes)]
222 #![deny(rustc::existing_doc_keyword)]
223 #![deny(fuzzy_provenance_casts)]
224 // Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`
225 #![deny(ffi_unwind_calls)]
226 // std may use features in a platform-specific way
227 #![allow(unused_features)]
230 #![cfg_attr(test, feature(internal_output_capture, print_internals, update_panic_count, rt))]
232 all(target_vendor
= "fortanix", target_env
= "sgx"),
233 feature(slice_index_methods
, coerce_unsized
, sgx_platform
)
236 // Language features:
237 #![feature(alloc_error_handler)]
238 #![feature(allocator_internals)]
239 #![feature(allow_internal_unsafe)]
240 #![feature(allow_internal_unstable)]
241 #![feature(box_syntax)]
242 #![feature(c_unwind)]
243 #![feature(cfg_target_thread_local)]
244 #![feature(concat_idents)]
245 #![feature(const_mut_refs)]
246 #![feature(const_trait_impl)]
247 #![feature(decl_macro)]
248 #![feature(deprecated_suggestion)]
250 #![feature(doc_cfg_hide)]
251 #![feature(doc_masked)]
252 #![feature(doc_notable_trait)]
253 #![feature(dropck_eyepatch)]
254 #![feature(exhaustive_patterns)]
255 #![feature(if_let_guard)]
256 #![feature(intra_doc_pointers)]
257 #![feature(is_terminal)]
258 #![feature(lang_items)]
259 #![feature(let_chains)]
261 #![feature(link_cfg)]
262 #![feature(min_specialization)]
263 #![feature(must_not_suspend)]
264 #![feature(needs_panic_runtime)]
265 #![feature(negative_impls)]
266 #![feature(never_type)]
267 #![feature(platform_intrinsics)]
268 #![feature(prelude_import)]
269 #![feature(rustc_attrs)]
270 #![feature(rustdoc_internals)]
271 #![feature(staged_api)]
272 #![feature(thread_local)]
273 #![feature(try_blocks)]
274 #![feature(utf8_chunks)]
276 // Library features (core):
277 #![feature(array_error_internals)]
278 #![feature(atomic_mut_ptr)]
279 #![feature(char_error_internals)]
280 #![feature(char_internals)]
281 #![feature(core_intrinsics)]
282 #![feature(cstr_from_bytes_until_nul)]
283 #![feature(cstr_internals)]
284 #![feature(duration_constants)]
285 #![feature(error_generic_member_access)]
286 #![feature(error_in_core)]
287 #![feature(error_iter)]
288 #![feature(exact_size_is_empty)]
289 #![feature(exclusive_wrapper)]
290 #![feature(extend_one)]
291 #![feature(float_minimum_maximum)]
292 #![feature(float_next_up_down)]
293 #![feature(hasher_prefixfree_extras)]
294 #![feature(hashmap_internals)]
295 #![feature(int_error_internals)]
296 #![feature(is_some_and)]
297 #![feature(maybe_uninit_slice)]
298 #![feature(maybe_uninit_write_slice)]
299 #![feature(nonnull_slice_from_raw_parts)]
300 #![feature(panic_can_unwind)]
301 #![feature(panic_info_message)]
302 #![feature(panic_internals)]
303 #![feature(pointer_byte_offsets)]
304 #![feature(pointer_is_aligned)]
305 #![feature(portable_simd)]
306 #![feature(prelude_2024)]
307 #![feature(provide_any)]
308 #![feature(ptr_as_uninit)]
309 #![feature(raw_os_nonzero)]
310 #![feature(slice_internals)]
311 #![feature(slice_ptr_get)]
312 #![feature(std_internals)]
313 #![feature(str_internals)]
314 #![feature(strict_provenance)]
315 #![feature(maybe_uninit_uninit_array)]
316 #![feature(const_maybe_uninit_uninit_array)]
317 #![feature(const_waker)]
319 // Library features (alloc):
320 #![feature(alloc_layout_extra)]
321 #![feature(allocator_api)]
322 #![feature(get_mut_unchecked)]
323 #![feature(map_try_insert)]
324 #![feature(new_uninit)]
325 #![feature(thin_box)]
326 #![feature(try_reserve_kind)]
327 #![feature(vec_into_raw_parts)]
328 #![feature(slice_concat_trait)]
330 // Library features (unwind):
331 #![feature(panic_unwind)]
333 // Only for re-exporting:
334 #![feature(assert_matches)]
335 #![feature(async_iterator)]
336 #![feature(c_variadic)]
337 #![feature(cfg_accessible)]
338 #![feature(cfg_eval)]
339 #![feature(concat_bytes)]
340 #![feature(const_format_args)]
341 #![feature(core_panic)]
342 #![feature(custom_test_frameworks)]
343 #![feature(edition_panic)]
344 #![feature(format_args_nl)]
345 #![feature(log_syntax)]
346 #![feature(once_cell)]
347 #![feature(saturating_int_impl)]
350 #![feature(trace_macros)]
351 #![feature(get_many_mut)]
353 // Only used in tests/benchmarks:
355 // Only for const-ness:
356 #![feature(const_collections_with_hasher)]
357 #![feature(const_hash)]
358 #![feature(const_io_structs)]
359 #![feature(const_ip)]
360 #![feature(const_ipv4)]
361 #![feature(const_ipv6)]
362 #![feature(const_socketaddr)]
363 #![feature(thread_local_internals)]
365 #![default_lib_allocator]
367 // Explicitly import the prelude. The compiler uses this same unstable attribute
368 // to import the prelude implicitly when building crates that depend on std.
371 use prelude
::rust_2021
::*;
373 // Access to Bencher, etc.
377 #[allow(unused_imports)] // macros from `alloc` are not used on all platforms
379 extern crate alloc
as alloc_crate
;
381 #[allow(unused_extern_crates)]
384 // We always need an unwinder currently for backtraces
386 #[allow(unused_extern_crates)]
390 #[allow(unused_extern_crates)]
391 #[cfg(feature = "miniz_oxide")]
392 extern crate miniz_oxide
;
394 // During testing, this crate is not actually the "real" std library, but rather
395 // it links to the real std library, which was compiled from this same source
396 // code. So any lang items std defines are conditionally excluded (or else they
397 // would generate duplicate lang item errors), and any globals it defines are
398 // _not_ the globals used by "real" std. So this import, defined only during
399 // testing gives test-std access to real-std lang items and globals. See #2912
401 extern crate std
as realstd
;
403 // The standard macros that are not built-in to the compiler.
407 // The runtime entry point and a few unstable public functions used by the
415 // Public module declarations and re-exports
416 #[stable(feature = "rust1", since = "1.0.0")]
417 pub use alloc_crate
::borrow
;
418 #[stable(feature = "rust1", since = "1.0.0")]
419 pub use alloc_crate
::boxed
;
420 #[stable(feature = "rust1", since = "1.0.0")]
421 pub use alloc_crate
::fmt
;
422 #[stable(feature = "rust1", since = "1.0.0")]
423 pub use alloc_crate
::format
;
424 #[stable(feature = "rust1", since = "1.0.0")]
425 pub use alloc_crate
::rc
;
426 #[stable(feature = "rust1", since = "1.0.0")]
427 pub use alloc_crate
::slice
;
428 #[stable(feature = "rust1", since = "1.0.0")]
429 pub use alloc_crate
::str;
430 #[stable(feature = "rust1", since = "1.0.0")]
431 pub use alloc_crate
::string
;
432 #[stable(feature = "rust1", since = "1.0.0")]
433 pub use alloc_crate
::vec
;
434 #[stable(feature = "rust1", since = "1.0.0")]
436 #[stable(feature = "core_array", since = "1.36.0")]
438 #[unstable(feature = "async_iterator", issue = "79024")]
439 pub use core
::async_iter
;
440 #[stable(feature = "rust1", since = "1.0.0")]
442 #[stable(feature = "rust1", since = "1.0.0")]
444 #[stable(feature = "rust1", since = "1.0.0")]
446 #[stable(feature = "rust1", since = "1.0.0")]
448 #[stable(feature = "rust1", since = "1.0.0")]
449 pub use core
::convert
;
450 #[stable(feature = "rust1", since = "1.0.0")]
451 pub use core
::default;
452 #[stable(feature = "futures_api", since = "1.36.0")]
453 pub use core
::future
;
454 #[stable(feature = "rust1", since = "1.0.0")]
456 #[stable(feature = "core_hint", since = "1.27.0")]
458 #[stable(feature = "i128", since = "1.26.0")]
459 #[allow(deprecated, deprecated_in_future)]
461 #[stable(feature = "rust1", since = "1.0.0")]
462 #[allow(deprecated, deprecated_in_future)]
464 #[stable(feature = "rust1", since = "1.0.0")]
465 #[allow(deprecated, deprecated_in_future)]
467 #[stable(feature = "rust1", since = "1.0.0")]
468 #[allow(deprecated, deprecated_in_future)]
470 #[stable(feature = "rust1", since = "1.0.0")]
471 #[allow(deprecated, deprecated_in_future)]
473 #[stable(feature = "rust1", since = "1.0.0")]
474 pub use core
::intrinsics
;
475 #[stable(feature = "rust1", since = "1.0.0")]
476 #[allow(deprecated, deprecated_in_future)]
478 #[stable(feature = "rust1", since = "1.0.0")]
480 #[stable(feature = "rust1", since = "1.0.0")]
481 pub use core
::marker
;
482 #[stable(feature = "rust1", since = "1.0.0")]
484 #[stable(feature = "rust1", since = "1.0.0")]
486 #[stable(feature = "rust1", since = "1.0.0")]
487 pub use core
::option
;
488 #[stable(feature = "pin", since = "1.33.0")]
490 #[stable(feature = "rust1", since = "1.0.0")]
492 #[stable(feature = "rust1", since = "1.0.0")]
493 pub use core
::result
;
494 #[stable(feature = "i128", since = "1.26.0")]
495 #[allow(deprecated, deprecated_in_future)]
497 #[stable(feature = "rust1", since = "1.0.0")]
498 #[allow(deprecated, deprecated_in_future)]
500 #[stable(feature = "rust1", since = "1.0.0")]
501 #[allow(deprecated, deprecated_in_future)]
503 #[stable(feature = "rust1", since = "1.0.0")]
504 #[allow(deprecated, deprecated_in_future)]
506 #[stable(feature = "rust1", since = "1.0.0")]
507 #[allow(deprecated, deprecated_in_future)]
509 #[stable(feature = "rust1", since = "1.0.0")]
510 #[allow(deprecated, deprecated_in_future)]
535 // Pull in `std_float` crate into std. The contents of
536 // `std_float` are in a different repository: rust-lang/portable-simd.
537 #[path = "../../portable-simd/crates/std_float/src/lib.rs"]
538 #[allow(missing_debug_implementations, dead_code, unsafe_op_in_unsafe_fn, unused_unsafe)]
539 #[allow(rustdoc::bare_urls)]
540 #[unstable(feature = "portable_simd", issue = "86656")]
543 #[doc = include_str!("../../portable-simd/crates/core_simd/src/core_simd_docs.md")]
544 #[unstable(feature = "portable_simd", issue = "86656")]
547 pub use crate::std_float
::StdFloat
;
549 pub use core
::simd
::*;
552 #[stable(feature = "futures_api", since = "1.36.0")]
554 //! Types and Traits for working with asynchronous tasks.
557 #[stable(feature = "futures_api", since = "1.36.0")]
558 pub use core
::task
::*;
561 #[stable(feature = "wake_trait", since = "1.51.0")]
562 pub use alloc
::task
::*;
565 #[doc = include_str!("../../stdarch/crates/core_arch/src/core_arch_docs.md")]
566 #[stable(feature = "simd_arch", since = "1.27.0")]
568 #[stable(feature = "simd_arch", since = "1.27.0")]
569 // The `no_inline`-attribute is required to make the documentation of all
570 // targets available.
571 // See https://github.com/rust-lang/rust/pull/57808#issuecomment-457390549 for
573 #[doc(no_inline)] // Note (#82861): required for correct documentation
574 pub use core
::arch
::*;
576 #[stable(feature = "simd_aarch64", since = "1.60.0")]
577 pub use std_detect
::is_aarch64_feature_detected
;
578 #[stable(feature = "simd_x86", since = "1.27.0")]
579 pub use std_detect
::is_x86_feature_detected
;
580 #[unstable(feature = "stdsimd", issue = "48556")]
581 pub use std_detect
::{
582 is_arm_feature_detected
, is_mips64_feature_detected
, is_mips_feature_detected
,
583 is_powerpc64_feature_detected
, is_powerpc_feature_detected
, is_riscv_feature_detected
,
587 // This was stabilized in the crate root so we have to keep it there.
588 #[stable(feature = "simd_x86", since = "1.27.0")]
589 pub use std_detect
::is_x86_feature_detected
;
591 // Platform-abstraction modules
597 // Private support modules
601 #[path = "../../backtrace/src/lib.rs"]
602 #[allow(dead_code, unused_attributes, fuzzy_provenance_casts)]
605 // Re-export macros defined in core.
606 #[stable(feature = "rust1", since = "1.0.0")]
607 #[allow(deprecated, deprecated_in_future)]
609 assert_eq
, assert_ne
, debug_assert
, debug_assert_eq
, debug_assert_ne
, matches
, todo
, r
#try,
610 unimplemented
, unreachable
, write
, writeln
,
613 // Re-export built-in macros defined through core.
614 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
617 assert
, assert_matches
, cfg
, column
, compile_error
, concat
, concat_idents
, const_format_args
,
618 env
, file
, format_args
, format_args_nl
, include
, include_bytes
, include_str
, line
, log_syntax
,
619 module_path
, option_env
, stringify
, trace_macros
,
623 feature
= "concat_bytes",
625 reason
= "`concat_bytes` is not stable enough for use and is subject to change"
627 pub use core
::concat_bytes
;
629 #[stable(feature = "core_primitive", since = "1.43.0")]
630 pub use core
::primitive
;
632 // Include a number of private modules that exist solely to provide
633 // the rustdoc documentation for primitive types. Using `include!`
634 // because rustdoc only looks for these modules at the crate level.
635 include
!("primitive_docs.rs");
637 // Include a number of private modules that exist solely to provide
638 // the rustdoc documentation for the existing keywords. Using `include!`
639 // because rustdoc only looks for these modules at the crate level.
640 include
!("keyword_docs.rs");
642 // This is required to avoid an unstable error when `restricted-std` is not
643 // enabled. The use of #![feature(restricted_std)] in rustc-std-workspace-std
644 // is unconditional, so the unstable feature needs to be defined somewhere.
645 #[unstable(feature = "restricted_std", issue = "none")]
646 mod __restricted_std_workaround {}
649 /// This trait being unreachable from outside the crate
650 /// prevents outside implementations of our extension traits.
651 /// This allows adding more trait methods in the future.
652 #[unstable(feature = "sealed", issue = "none")]
657 #[allow(dead_code)] // Not used in all configurations.
658 pub(crate) mod test_helpers
{
659 /// Test-only replacement for `rand::thread_rng()`, which is unusable for
660 /// us, as we want to allow running stdlib tests on tier-3 targets which may
661 /// not have `getrandom` support.
663 /// Does a bit of a song and dance to ensure that the seed is different on
664 /// each call (as some tests sadly rely on this), but doesn't try that hard.
666 /// This is duplicated in the `core`, `alloc` test suites (as well as
667 /// `std`'s integration tests), but figuring out a mechanism to share these
668 /// seems far more painful than copy-pasting a 7 line function a couple
669 /// times, given that even under a perma-unstable feature, I don't think we
670 /// want to expose types from `rand` from `std`.
672 pub(crate) fn test_rng() -> rand_xorshift
::XorShiftRng
{
673 use core
::hash
::{BuildHasher, Hash, Hasher}
;
674 let mut hasher
= crate::collections
::hash_map
::RandomState
::new().build_hasher();
675 core
::panic
::Location
::caller().hash(&mut hasher
);
676 let hc64
= hasher
.finish();
677 let seed_vec
= hc64
.to_le_bytes().into_iter().chain(0u8..8).collect
::<Vec
<u8>>();
678 let seed
: [u8; 16] = seed_vec
.as_slice().try_into().unwrap();
679 rand
::SeedableRng
::from_seed(seed
)