Merge branch 'master' of https://github.com/rust-lang/rust-by-example

Author: Speedy-Consoles

src/custom_types/enum/enum_use.md

@@ -19,9 +19,9 @@ enum Work {
 fn main() {
     // Explicitly `use` each name so they are available without
     // manual scoping.
-    use Status::{Poor, Rich};
+    use crate::Status::{Poor, Rich};
     // Automatically `use` each name inside `Work`.
-    use Work::*;
+    use crate::Work::*;
 
     // Equivalent to `Status::Poor`.
     let status = Poor;

src/custom_types/enum/testcase_linked_list.md

@@ -3,7 +3,7 @@
 A common use for `enums` is to create a linked-list:
 
 ```rust,editable
-use List::*;
+use crate::List::*;
 
 enum List {
     // Cons: Tuple struct that wraps an element and a pointer to the next node

src/macros/dry.md

@@ -10,7 +10,7 @@ use std::ops::{Add, Mul, Sub};
 macro_rules! assert_equal_len {
     // The `tt` (token tree) designator is used for
     // operators and tokens.
-    ($a:ident, $b: ident, $func:ident, $op:tt) => (
+    ($a:ident, $b:ident, $func:ident, $op:tt) => (
         assert!($a.len() == $b.len(),
                 "{:?}: dimension mismatch: {:?} {:?} {:?}",
                 stringify!($func),
@@ -41,7 +41,7 @@ op!(sub_assign, Sub, -=, sub);
 mod test {
     use std::iter;
     macro_rules! test {
-        ($func: ident, $x:expr, $y:expr, $z:expr) => {
+        ($func:ident, $x:expr, $y:expr, $z:expr) => {
             #[test]
             fn $func() {
                 for size in 0usize..10 {

src/mod/super.md

@@ -44,7 +44,7 @@ mod my {
         // This will bind to the `cool::function` in the *crate* scope.
         // In this case the crate scope is the outermost scope.
         {
-            use cool::function as root_function;
+            use crate::cool::function as root_function;
             root_function();
         }
     }
@@ -53,4 +53,4 @@ mod my {
 fn main() {
     my::indirect_call();
 }
-```
+```

src/mod/use.md

@@ -6,7 +6,7 @@ access. It is often used like this:
 ```rust,editable,ignore
 // extern crate deeply; // normally, this would exist and not be commented out!
 
-use deeply::nested::{
+use crate::deeply::nested::{
     my_first_function,
     my_second_function,
     AndATraitType
@@ -43,7 +43,7 @@ fn main() {
     {
         // This is equivalent to `use deeply::nested::function as function`.
         // This `function()` will shadow the outer one.
-        use deeply::nested::function;
+        use crate::deeply::nested::function;
         function();
 
         // `use` bindings have a local scope. In this case, the

src/mod/visibility.md

@@ -37,7 +37,7 @@ mod my_mod {
 
         // Functions declared using `pub(in path)` syntax are only visible
         // within the given path. `path` must be a parent or ancestor module
-        pub(in my_mod) fn public_function_in_my_mod() {
+        pub(in crate::my_mod) fn public_function_in_my_mod() {
             print!("called `my_mod::nested::public_function_in_my_mod()`, that\n > ");
             public_function_in_nested()
         }

src/trait/derive.md

@@ -6,9 +6,9 @@ manually implemented if a more complex behavior is required.
 
 The following is a list of derivable traits:
 * Comparison traits:
-  [`Eq`][eq], [`PartialEq`][partial-eq], [`Ord`][ord], [`PartialOrd`][partial-ord]
+  [`Eq`][eq], [`PartialEq`][partial-eq], [`Ord`][ord], [`PartialOrd`][partial-ord].
 * [`Clone`][clone], to create `T` from `&T` via a copy.
-* [`Copy`][copy], to give a type 'copy semantics' instead of 'move semantics'
+* [`Copy`][copy], to give a type 'copy semantics' instead of 'move semantics'.
 * [`Hash`][hash], to compute a hash from `&T`.
 * [`Default`][default], to create an empty instance of a data type.
 * [`Debug`][debug], to format a value using the `{:?}` formatter.