diff --git a/src/doc/book/bibliography.md b/src/doc/book/bibliography.md index d32b1a91944e4..6f6f51d1f6082 100644 --- a/src/doc/book/bibliography.md +++ b/src/doc/book/bibliography.md @@ -80,3 +80,4 @@ Language](http://www.cs.indiana.edu/~eholk/papers/hips2013.pdf). Early GPU work Rust](http://munksgaard.me/papers/laumann-munksgaard-larsen.pdf). Philip Munksgaard's master's thesis. Research for Servo. * [Ownership is Theft: Experiences Building an Embedded OS in Rust - Amit Levy, et. al.](http://amitlevy.com/papers/tock-plos2015.pdf) +* [You can't spell trust without Rust](https://raw.githubusercontent.com/Gankro/thesis/master/thesis.pdf). Alexis Beingessner's master's thesis. diff --git a/src/doc/book/error-handling.md b/src/doc/book/error-handling.md index 9b1d16170b97f..d4df6a813bc80 100644 --- a/src/doc/book/error-handling.md +++ b/src/doc/book/error-handling.md @@ -351,11 +351,28 @@ fn file_name(file_path: &str) -> Option<&str> { ``` You might think that we could use the `map` combinator to reduce the case -analysis, but its type doesn't quite fit. Namely, `map` takes a function that -does something only with the inner value. The result of that function is then -*always* [rewrapped with `Some`](#code-option-map). Instead, we need something -like `map`, but which allows the caller to return another `Option`. Its generic -implementation is even simpler than `map`: +analysis, but its type doesn't quite fit... + +```rust +fn file_path_ext(file_path: &str) -> Option<&str> { + file_name(file_path).map(|x| extension(x)) //Compilation error +} +``` + +The `map` function here wraps the value returned by the `extension` function +inside an `Option<_>` and since the `extension` function itself returns an +`Option<&str>` the expression `file_name(file_path).map(|x| extension(x))` +actually returns an `Option>`. + +But since `file_path_ext` just returns `Option<&str>` (and not +`Option>`) we get a compilation error. + +The result of the function taken by map as input is *always* [rewrapped with +`Some`](#code-option-map). Instead, we need something like `map`, but which +allows the caller to return a `Option<_>` directly without wrapping it in +another `Option<_>`. + +Its generic implementation is even simpler than `map`: ```rust fn and_then(option: Option, f: F) -> Option @@ -377,6 +394,10 @@ fn file_path_ext(file_path: &str) -> Option<&str> { } ``` +Side note: Since `and_then` essentially works like `map` but returns an +`Option<_>` instead of an `Option>` it is known as `flatmap` in some +other languages. + The `Option` type has many other combinators [defined in the standard library][5]. It is a good idea to skim this list and familiarize yourself with what's available—they can often reduce case analysis diff --git a/src/doc/book/getting-started.md b/src/doc/book/getting-started.md index e9d271e753768..18d5ca5be1ae3 100644 --- a/src/doc/book/getting-started.md +++ b/src/doc/book/getting-started.md @@ -111,7 +111,7 @@ If we're on Linux or a Mac, all we need to do is open a terminal and type this: $ curl -sSf https://static.rust-lang.org/rustup.sh | sh ``` -This will download a script, and stat the installation. If it all goes well, +This will download a script, and start the installation. If it all goes well, you’ll see this appear: ```text diff --git a/src/doc/book/guessing-game.md b/src/doc/book/guessing-game.md index 2e315333565c7..80aca56bd1e9f 100644 --- a/src/doc/book/guessing-game.md +++ b/src/doc/book/guessing-game.md @@ -908,6 +908,7 @@ let guess: u32 = match guess.trim().parse() { ``` This is how you generally move from ‘crash on error’ to ‘actually handle the +error’, by switching from `expect()` to a `match` statement. The `Result` returned by `parse()` is an `enum` like `Ordering`, but in this case, each variant has some data associated with it: `Ok` is a success, and `Err` is a failure. Each contains more information: the successfully parsed integer, or an diff --git a/src/doc/book/no-stdlib.md b/src/doc/book/no-stdlib.md index 65beaed2fc7e9..610940cde95e6 100644 --- a/src/doc/book/no-stdlib.md +++ b/src/doc/book/no-stdlib.md @@ -77,10 +77,11 @@ The compiler currently makes a few assumptions about symbols which are available in the executable to call. Normally these functions are provided by the standard library, but without it you must define your own. -The first of these two functions, `eh_personality`, is used by the -failure mechanisms of the compiler. This is often mapped to GCC's -personality function (see the -[libstd implementation](../std/rt/unwind/index.html) for more -information), but crates which do not trigger a panic can be assured -that this function is never called. The second function, `panic_fmt`, is -also used by the failure mechanisms of the compiler. +The first of these two functions, `eh_personality`, is used by the failure +mechanisms of the compiler. This is often mapped to GCC's personality function +(see the [libstd implementation][unwind] for more information), but crates +which do not trigger a panic can be assured that this function is never +called. The second function, `panic_fmt`, is also used by the failure +mechanisms of the compiler. + +[unwind]: https://github.com/rust-lang/rust/blob/master/src/libstd/sys/common/unwind/gcc.rs diff --git a/src/doc/book/traits.md b/src/doc/book/traits.md index d40689190e7fe..2a164077683b2 100644 --- a/src/doc/book/traits.md +++ b/src/doc/book/traits.md @@ -277,16 +277,22 @@ This will compile without error. This means that even if someone does something bad like add methods to `i32`, it won’t affect you, unless you `use` that trait. -There’s one more restriction on implementing traits: either the trait, or the -type you’re writing the `impl` for, must be defined by you. So, we could -implement the `HasArea` type for `i32`, because `HasArea` is in our code. But -if we tried to implement `ToString`, a trait provided by Rust, for `i32`, we could -not, because neither the trait nor the type are in our code. +There’s one more restriction on implementing traits: either the trait +or the type you’re implementing it for must be defined by you. Or more +precisely, one of them must be defined in the same crate as the `impl` +you're writing. For more on Rust's module and package system, see the +chapter on [crates and modules][cm]. + +So, we could implement the `HasArea` type for `i32`, because we defined +`HasArea` in our code. But if we tried to implement `ToString`, a trait +provided by Rust, for `i32`, we could not, because neither the trait nor +the type are defined in our crate. One last thing about traits: generic functions with a trait bound use ‘monomorphization’ (mono: one, morph: form), so they are statically dispatched. What’s that mean? Check out the chapter on [trait objects][to] for more details. +[cm]: crates-and-modules.html [to]: trait-objects.html # Multiple trait bounds diff --git a/src/doc/version_info.html.template b/src/doc/version_info.html.template index 2fda57923cd8f..7215e4f13c9bb 100644 --- a/src/doc/version_info.html.template +++ b/src/doc/version_info.html.template @@ -1,5 +1,5 @@
-
+ Rust logo
Rust VERSION
SHORT_HASH diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 492263da2bc5b..0ced4e1952aa5 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -1194,7 +1194,7 @@ unsafe fn unwrap_unchecked(val: Option) -> T { } impl BTreeMap { - /// Gets an iterator over the entries of the map. + /// Gets an iterator over the entries of the map, sorted by key. /// /// # Examples /// @@ -1202,9 +1202,9 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1, "a"); - /// map.insert(2, "b"); /// map.insert(3, "c"); + /// map.insert(2, "b"); + /// map.insert(1, "a"); /// /// for (key, value) in map.iter() { /// println!("{}: {}", key, value); @@ -1224,7 +1224,7 @@ impl BTreeMap { } } - /// Gets a mutable iterator over the entries of the map. + /// Gets a mutable iterator over the entries of the map, sorted by key. /// /// # Examples /// @@ -1257,7 +1257,7 @@ impl BTreeMap { } } - /// Gets an iterator over the keys of the map. + /// Gets an iterator over the keys of the map, in sorted order. /// /// # Examples /// @@ -1265,8 +1265,8 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut a = BTreeMap::new(); - /// a.insert(1, "a"); /// a.insert(2, "b"); + /// a.insert(1, "a"); /// /// let keys: Vec<_> = a.keys().cloned().collect(); /// assert_eq!(keys, [1, 2]); @@ -1276,7 +1276,7 @@ impl BTreeMap { Keys { inner: self.iter() } } - /// Gets an iterator over the values of the map. + /// Gets an iterator over the values of the map, in order by key. /// /// # Examples /// @@ -1284,11 +1284,11 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut a = BTreeMap::new(); - /// a.insert(1, "a"); - /// a.insert(2, "b"); + /// a.insert(1, "hello"); + /// a.insert(2, "goodbye"); /// /// let values: Vec<&str> = a.values().cloned().collect(); - /// assert_eq!(values, ["a", "b"]); + /// assert_eq!(values, ["hello", "goodbye"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn values<'a>(&'a self) -> Values<'a, K, V> { diff --git a/src/librustc_borrowck/diagnostics.rs b/src/librustc_borrowck/diagnostics.rs index 1f5824f82e486..7ad4d3ca70898 100644 --- a/src/librustc_borrowck/diagnostics.rs +++ b/src/librustc_borrowck/diagnostics.rs @@ -124,7 +124,7 @@ fn main() { let mut x = Rc::new(RefCell::new(MyStruct{ s: 5u32 })); let y = x.clone(); x.borrow_mut().s = 6; - println!("{}", x.borrow.s); + println!("{}", x.borrow().s); } ``` diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index 04ab3fe70e9fa..dc6da1f0ef847 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -207,7 +207,41 @@ https://doc.rust-lang.org/reference.html#statements E0317: r##" User-defined types or type parameters cannot shadow the primitive types. This error indicates you tried to define a type, struct or enum with the same -name as an existing primitive type. +name as an existing primitive type: + +``` +struct u8 { + // ... +} +``` + +To fix this, simply name it something else. + +Such an error may also occur if you define a type parameter which shadows a +primitive type. An example would be something like: + +``` +impl MyTrait for Option { + // ... +} +``` + +In such a case, if you meant for `u8` to be a generic type parameter (i.e. any +type can be used in its place), use something like `T` instead: + +``` +impl MyTrait for Option { + // ... +} +``` + +On the other hand, if you wished to refer to the specific type `u8`, remove it +from the type parameter list: + +``` +impl MyTrait for Option { + // ... +} See the Types section of the reference for more information about the primitive types: diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 0e095ed674d0e..db4f8d3a70c40 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1918,8 +1918,8 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, lint::builtin::INVALID_TYPE_PARAM_DEFAULT, param.id, param.span, - format!("defaults for type parameters are only allowed on type definitions, \ - like `struct` or `enum`")); + format!("defaults for type parameters are only allowed in `struct`, \ + `enum`, `type`, or `trait` definitions.")); } } diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs index fdc23f89de237..8f7692c794540 100644 --- a/src/librustc_typeck/diagnostics.rs +++ b/src/librustc_typeck/diagnostics.rs @@ -2269,6 +2269,8 @@ struct MyType(T); impl ForeignTrait for MyType { ... } // Ok ``` +Please note that a type alias is not sufficient. + For another example of an error, suppose there's another trait defined in `foo` named `ForeignTrait2` that takes two type parameters. Then this `impl` results in the same rule violation: diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs index 227981d68fbb4..ffcd22fa82096 100644 --- a/src/librustdoc/html/layout.rs +++ b/src/librustdoc/html/layout.rs @@ -148,7 +148,7 @@ r##" "".to_string() } else { format!("\ - ", + logo", page.root_path, layout.krate, layout.logo) }, diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index 0bde582c19f28..c751cdeb6f790 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -383,7 +383,7 @@ a { } .content span.enum, .content a.enum, .block a.current.enum { color: #5e9766; } -.content span.struct, .content a.struct, .block a.current.struct { color: #e53700; } +.content span.struct, .content a.struct, .block a.current.struct { color: #df3600; } .content a.type { color: #e57300; } .content a.macro { color: #068000; } .block a.current.crate { font-weight: 500; } diff --git a/src/librustdoc/html/static/styles/main.css b/src/librustdoc/html/static/styles/main.css index e138d62f986c1..02bb5221886df 100644 --- a/src/librustdoc/html/static/styles/main.css +++ b/src/librustdoc/html/static/styles/main.css @@ -106,14 +106,14 @@ a { } .docblock a, .stability a { - color: #4e8bca; + color: #3873AD; } a.test-arrow { color: #f5f5f5; } -.content span.trait, .content a.trait, .block a.current.trait { color: #8866ff; } +.content span.trait, .content a.trait, .block a.current.trait { color: #7c5af3; } .search-input { color: #555; diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index e43101b7c9d0d..43bf86a00399c 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -272,6 +272,35 @@ fn test_resize_policy() { /// } /// ``` /// +/// `HashMap` also implements an [`Entry API`](#method.entry), which allows +/// for more complex methods of getting, setting, updating and removing keys and +/// their values: +/// +/// ``` +/// use std::collections::HashMap; +/// +/// // type inference lets us omit an explicit type signature (which +/// // would be `HashMap<&str, u8>` in this example). +/// let mut player_stats = HashMap::new(); +/// +/// fn random_stat_buff() -> u8 { +/// // could actually return some random value here - let's just return +/// // some fixed value for now +/// 42 +/// } +/// +/// // insert a key only if it doesn't already exist +/// player_stats.entry("health").or_insert(100); +/// +/// // insert a key using a function that provides a new value only if it +/// // doesn't already exist +/// player_stats.entry("defence").or_insert_with(random_stat_buff); +/// +/// // update a key, guarding against the key possibly not being set +/// let stat = player_stats.entry("attack").or_insert(100); +/// *stat += random_stat_buff(); +/// ``` +/// /// The easiest way to use `HashMap` with a custom type as key is to derive `Eq` and `Hash`. /// We must also derive `PartialEq`. /// diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index d6aa746f4cb53..9d505607a60c4 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -407,7 +407,6 @@ impl CStr { /// # fn main() { /// use std::ffi::CStr; /// use std::os::raw::c_char; - /// use std::str; /// /// extern { /// fn my_string() -> *const c_char; @@ -415,8 +414,7 @@ impl CStr { /// /// unsafe { /// let slice = CStr::from_ptr(my_string()); - /// println!("string returned: {}", - /// str::from_utf8(slice.to_bytes()).unwrap()); + /// println!("string returned: {}", slice.to_str().unwrap()); /// } /// # } /// ``` diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs index 414a0ebd11fa2..187a1797dac04 100644 --- a/src/libstd/fs.rs +++ b/src/libstd/fs.rs @@ -414,7 +414,7 @@ impl OpenOptions { /// This option, when true, will indicate that the file should be /// `write`-able if opened. /// - /// If a file already exist, any write calls on the file will overwrite its + /// If the file already exists, any write calls on it will overwrite its /// contents, without truncating it. /// /// # Examples @@ -487,8 +487,8 @@ impl OpenOptions { /// This option indicates whether a new file will be created if the file /// does not yet already exist. /// - /// The file must be opened with write or append access in order to create - /// a new file. + /// In order for the file to be created, `write` or `append` access must + /// be used. /// /// # Examples /// diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs index 8f08c840c218b..ac5ce298c5c6f 100644 --- a/src/libstd/sync/semaphore.rs +++ b/src/libstd/sync/semaphore.rs @@ -13,7 +13,7 @@ of resources is currently unclear", issue = "27798")] #![rustc_deprecated(since = "1.7.0", - reason = "easily confused with system sempahores and not \ + reason = "easily confused with system semaphores and not \ used enough to pull its weight")] #![allow(deprecated)] diff --git a/src/test/auxiliary/issue_30123_aux.rs b/src/test/auxiliary/issue_30123_aux.rs new file mode 100644 index 0000000000000..f60311a9400b3 --- /dev/null +++ b/src/test/auxiliary/issue_30123_aux.rs @@ -0,0 +1,33 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::marker::PhantomData; + +pub struct Directed; +pub struct Undirected; + +pub struct Graph { + nodes: Vec>, + edges: Vec>, + ty: PhantomData, +} + + +impl Graph { + pub fn new() -> Self { + Graph{nodes: Vec::new(), edges: Vec::new(), ty: PhantomData} + } +} + +impl Graph { + pub fn new_undirected() -> Self { + Graph{nodes: Vec::new(), edges: Vec::new(), ty: PhantomData} + } +} diff --git a/src/test/compile-fail/issue-30123.rs b/src/test/compile-fail/issue-30123.rs new file mode 100644 index 0000000000000..cfd3cd3af3ebc --- /dev/null +++ b/src/test/compile-fail/issue-30123.rs @@ -0,0 +1,19 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:issue_30123_aux.rs + +extern crate issue_30123_aux; +use issue_30123_aux::*; + +fn main() { + let ug = Graph::::new_undirected(); + //~^ ERR no associated item named `new_undirected` found for type +}