Standardize punctuation & formatting of TRPL

This commit is an attempt to standardize the use of punctuation and
formatting in "The Rust Programming Language" as discussed in #19823.

- Convert bold text to italicized textcwhen referring to terminology.
- Convert single-quoted text to italicized or double-quoted text,
  depending on context.
- Use double quotes only in the case of scare quotes or quotations.

1 files changed, 6 insertions, 6 deletions

diff --git a/src/doc/trpl/variable-bindings.md b/src/doc/trpl/variable-bindings.md
index 4e2e7bd2fe2..aa99caa731f 100644
--- a/src/doc/trpl/variable-bindings.md
+++ b/src/doc/trpl/variable-bindings.md
@@ -1,6 +1,6 @@
 % Variable bindings
 
-The first thing we'll learn about are 'variable bindings.' They look like this:
+The first thing we'll learn about are *variable bindings*. They look like this:
 
 ```{rust}
 fn main() {
@@ -12,9 +12,9 @@ Putting `fn main() {` in each example is a bit tedious, so we'll leave that out
 in the future. If you're following along, make sure to edit your `main()`
 function, rather than leaving it off. Otherwise, you'll get an error.
 
-In many languages, this is called a 'variable.' But Rust's variable bindings
+In many languages, this is called a *variable*. But Rust's variable bindings
 have a few tricks up their sleeves. Rust has a very powerful feature called
-'pattern matching' that we'll get into detail with later, but the left
+*pattern matching* that we'll get into detail with later, but the left
 hand side of a `let` expression is a full pattern, not just a variable name.
 This means we can do things like:
 
@@ -28,7 +28,7 @@ So let's just keep this in the back of our minds as we go forward.
 
 Rust is a statically typed language, which means that we specify our types up
 front. So why does our first example compile? Well, Rust has this thing called
-"type inference." If it can figure out what the type of something is, Rust
+*type inference*. If it can figure out what the type of something is, Rust
 doesn't require you to actually type it out.
 
 We can add the type if we want to, though. Types come after a colon (`:`):
@@ -53,7 +53,7 @@ Note the similarities between this annotation and the syntax you use with `let`.
 Including these kinds of comments is not idiomatic Rust, but we'll occasionally
 include them to help you understand what the types that Rust infers are.
 
-By default, bindings are **immutable**. This code will not compile:
+By default, bindings are *immutable*. This code will not compile:
 
 ```{ignore}
 let x = 5;
@@ -162,7 +162,7 @@ talk about this stuff we've added to `println!`.
 
 If you include two curly braces (`{}`, some call them moustaches...) in your
 string to print, Rust will interpret this as a request to interpolate some sort
-of value. **String interpolation** is a computer science term that means "stick
+of value. *String interpolation* is a computer science term that means "stick
 in the middle of a string." We add a comma, and then `x`, to indicate that we
 want `x` to be the value we're interpolating. The comma is used to separate
 arguments we pass to functions and macros, if you're passing more than one.