rollup merge of #19336: apasel422/guide

[rust.git] / src / doc / guide.md

diff --git a/src/doc/guide.md b/src/doc/guide.md
index ada7d2945256911fb628e77a3dfc26d94e7d7d35..670af614b95a70e76a2f77e5c022f1cf0ec33b57 100644 (file)
--- a/src/doc/guide.md
+++ b/src/doc/guide.md
@@ -689,7 +689,7 @@ fn main() {
 ```
 
 This is the simplest possible function declaration. As we mentioned before,
-`fn` says 'this is a function,' followed by the name, some parenthesis because
+`fn` says 'this is a function,' followed by the name, some parentheses because
 this function takes no arguments, and then some curly braces to indicate the
 body. Here's a function named `foo`:
 
@@ -890,7 +890,7 @@ Tuples are an ordered list of a fixed size. Like this:
 let x = (1i, "hello");
 ```
 
-The parenthesis and commas form this two-length tuple. Here's the same code, but
+The parentheses and commas form this two-length tuple. Here's the same code, but
 with the type annotated:
 
 ```rust
@@ -914,9 +914,9 @@ let (x, y, z) = (1i, 2i, 3i);
 println!("x is {}", x);
 ```
 
-Remember before when I said the left hand side of a `let` statement was more
+Remember before when I said the left-hand side of a `let` statement was more
 powerful than just assigning a binding? Here we are. We can put a pattern on
-the left hand side of the `let`, and if it matches up to the right hand side,
+the left-hand side of the `let`, and if it matches up to the right-hand side,
 we can assign multiple bindings at once. In this case, `let` 'destructures,'
 or 'breaks up,' the tuple, and assigns the bits to three bindings.
 
@@ -1459,9 +1459,9 @@ focus. Any time you have a data structure of variable size, things can get
 tricky, and strings are a re-sizable data structure. That said, Rust's strings
 also work differently than in some other systems languages, such as C.
 
-Let's dig into the details. A **string** is a sequence of unicode scalar values
+Let's dig into the details. A **string** is a sequence of Unicode scalar values
 encoded as a stream of UTF-8 bytes. All strings are guaranteed to be
-validly-encoded UTF-8 sequences. Additionally, strings are not null-terminated
+validly encoded UTF-8 sequences. Additionally, strings are not null-terminated
 and can contain null bytes.
 
 Rust has two main types of strings: `&str` and `String`.
@@ -3939,7 +3939,7 @@ match x {
 }
 ```
 
-Here, the `val` inside the `match` has type `int`. In other words, the left hand
+Here, the `val` inside the `match` has type `int`. In other words, the left-hand
 side of the pattern destructures the value. If we have `&5i`, then in `&val`, `val`
 would be `5i`.
 
@@ -4716,7 +4716,7 @@ let x: Option<int> = Some(5i);
 
 In the type declaration, we say `Option<int>`. Note how similar this looks to
 `Option<T>`. So, in this particular `Option`, `T` has the value of `int`. On
-the right hand side of the binding, we do make a `Some(T)`, where `T` is `5i`.
+the right-hand side of the binding, we do make a `Some(T)`, where `T` is `5i`.
 Since that's an `int`, the two sides match, and Rust is happy. If they didn't
 match, we'd get an error: