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
//! 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. //! //! # 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`], [`Unpin`]}. 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::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 //! [`Unpin`]: ../marker/trait.Unpin.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/ch13-01-closures.html //! [book-dtor]: ../../book/ch15-03-drop.html //! [book-enums]: ../../book/ch06-01-defining-an-enum.html //! [book-iter]: ../../book/ch13-02-iterators.html #![stable(feature = "rust1", since = "1.0.0")] pub mod v1;