      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138

    //! The Rust Prelude.
    //!
    //! Rust comes with a variety of things in its standard library. However, if
    //! you had to manually import every single thing that you used, it would be
    //! very verbose. But importing a lot of things that a program never uses isn't
    //! good either. A balance needs to be struck.
    //!
    //! The *prelude* is the list of things that Rust automatically imports into
    //! every Rust program. It's kept as small as possible, and is focused on
    //! things, particularly traits, which are used in almost every single Rust
    //! program.
    //!
    //! On a technical level, Rust inserts
    //!
    //! ```
    //! # #[allow(unused_extern_crates)]
    //! extern crate std;
    //! ```
    //!
    //! into the crate root of every crate, and
    //!
    //! ```
    //! # #[allow(unused_imports)]
    //! use std::prelude::v1::*;
    //! ```
    //!
    //! into every module.
    //!
    //! # Other preludes
    //!
    //! Preludes can be seen as a pattern to make using multiple types more
    //! convenient. As such, you'll find other preludes in the standard library,
    //! such as [`std::io::prelude`]. Various libraries in the Rust ecosystem may
    //! also define their own preludes.
    //!
    //! [`std::io::prelude`]: ../io/prelude/index.html
    //!
    //! The difference between 'the prelude' and these other preludes is that they
    //! are not automatically `use`'d, and must be imported manually. This is still
    //! easier than importing all of their constituent components.
    //!
    //! # Prelude contents
    //!
    //! The current version of the prelude (version 1) lives in
    //! [`std::prelude::v1`], and re-exports the following.
    //!
    //! * [`std::marker`]::{[`Copy`], [`Send`], [`Sized`], [`Sync`]}. The marker
    //!   traits indicate fundamental properties of types.
    //! * [`std::ops`]::{[`Drop`], [`Fn`], [`FnMut`], [`FnOnce`]}. Various
    //!   operations for both destructors and overloading `()`.
    //! * [`std::mem`]::[`drop`][`mem::drop`], a convenience function for explicitly
    //!   dropping a value.
    //! * [`std::boxed`]::[`Box`], a way to allocate values on the heap.
    //! * [`std::borrow`]::[`ToOwned`], The conversion trait that defines
    //!   [`to_owned`], the generic method for creating an owned type from a
    //!   borrowed type.
    //! * [`std::clone`]::[`Clone`], the ubiquitous trait that defines
    //!   [`clone`][`Clone::clone`], the method for producing a copy of a value.
    //! * [`std::cmp`]::{[`PartialEq`], [`PartialOrd`], [`Eq`], [`Ord`] }. The
    //!   comparison traits, which implement the comparison operators and are often
    //!   seen in trait bounds.
    //! * [`std::convert`]::{[`AsRef`], [`AsMut`], [`Into`], [`From`]}. Generic
    //!   conversions, used by savvy API authors to create overloaded methods.
    //! * [`std::default`]::[`Default`], types that have default values.
    //! * [`std::iter`]::{[`Iterator`], [`Extend`], [`IntoIterator`],
    //!   [`DoubleEndedIterator`], [`ExactSizeIterator`]}. Iterators of various
    //!   kinds.
    //! * [`std::option`]::[`Option`]::{`self`, `Some`, `None`}. A type which
    //!   expresses the presence or absence of a value. This type is so commonly
    //!   used, its variants are also exported.
    //! * [`std::result`]::[`Result`]::{`self`, `Ok`, `Err`}. A type for functions
    //!   that may succeed or fail. Like [`Option`], its variants are exported as
    //!   well.
    //! * [`std::slice`]::[`SliceConcatExt`], a trait that exists for technical
    //!   reasons, but shouldn't have to exist. It provides a few useful methods on
    //!   slices.
    //! * [`std::string`]::{[`String`], [`ToString`]}, heap allocated strings.
    //! * [`std::vec`]::[`Vec`](../vec/struct.Vec.html), a growable, heap-allocated
    //!   vector.
    //!
    //! [`AsMut`]: ../convert/trait.AsMut.html
    //! [`AsRef`]: ../convert/trait.AsRef.html
    //! [`Box`]: ../boxed/struct.Box.html
    //! [`Clone`]: ../clone/trait.Clone.html
    //! [`Copy`]: ../marker/trait.Copy.html
    //! [`Default`]: ../default/trait.Default.html
    //! [`DoubleEndedIterator`]: ../iter/trait.DoubleEndedIterator.html
    //! [`Drop`]: ../ops/trait.Drop.html
    //! [`Eq`]: ../cmp/trait.Eq.html
    //! [`ExactSizeIterator`]: ../iter/trait.ExactSizeIterator.html
    //! [`Extend`]: ../iter/trait.Extend.html
    //! [`FnMut`]: ../ops/trait.FnMut.html
    //! [`FnOnce`]: ../ops/trait.FnOnce.html
    //! [`Fn`]: ../ops/trait.Fn.html
    //! [`From`]: ../convert/trait.From.html
    //! [`IntoIterator`]: ../iter/trait.IntoIterator.html
    //! [`Into`]: ../convert/trait.Into.html
    //! [`Iterator`]: ../iter/trait.Iterator.html
    //! [`Option`]: ../option/enum.Option.html
    //! [`Ord`]: ../cmp/trait.Ord.html
    //! [`PartialEq`]: ../cmp/trait.PartialEq.html
    //! [`PartialOrd`]: ../cmp/trait.PartialOrd.html
    //! [`Result`]: ../result/enum.Result.html
    //! [`Send`]: ../marker/trait.Send.html
    //! [`Sized`]: ../marker/trait.Sized.html
    //! [`SliceConcatExt`]: ../slice/trait.SliceConcatExt.html
    //! [`String`]: ../string/struct.String.html
    //! [`Sync`]: ../marker/trait.Sync.html
    //! [`ToOwned`]: ../borrow/trait.ToOwned.html
    //! [`ToString`]: ../string/trait.ToString.html
    //! [`Vec`]: ../vec/struct.Vec.html
    //! [`Clone::clone`]: ../clone/trait.Clone.html#tymethod.clone
    //! [`mem::drop`]: ../mem/fn.drop.html
    //! [`std::borrow`]: ../borrow/index.html
    //! [`std::boxed`]: ../boxed/index.html
    //! [`std::clone`]: ../clone/index.html
    //! [`std::cmp`]: ../cmp/index.html
    //! [`std::convert`]: ../convert/index.html
    //! [`std::default`]: ../default/index.html
    //! [`std::iter`]: ../iter/index.html
    //! [`std::marker`]: ../marker/index.html
    //! [`std::mem`]: ../mem/index.html
    //! [`std::ops`]: ../ops/index.html
    //! [`std::option`]: ../option/index.html
    //! [`std::prelude::v1`]: v1/index.html
    //! [`std::result`]: ../result/index.html
    //! [`std::slice`]: ../slice/index.html
    //! [`std::string`]: ../string/index.html
    //! [`std::vec`]: ../vec/index.html
    //! [`to_owned`]: ../borrow/trait.ToOwned.html#tymethod.to_owned
    //! [book-closures]: ../../book/first-edition/closures.html
    //! [book-dtor]: ../../book/first-edition/drop.html
    //! [book-enums]: ../../book/first-edition/enums.html
    //! [book-iter]: ../../book/first-edition/iterators.html

    #![stable(feature = "rust1", since = "1.0.0")]

    pub mod v1;

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)