Replace all uses of bash syntax highlighting

Since none of these are actually bash scripts :)

Changed all the instances in the src files to text, which, since my PR
to mdbook got accepted, will still do code background colors but no
syntax highlighting.

Fixes #295 and #327.

Author: carols10cents

README.md

@@ -19,36 +19,36 @@ Building the book requires [mdBook] >= v0.0.13. To get it:
 
 [mdBook]: https://github.com/azerupi/mdBook
 
-```bash
+```
 $ cargo install mdbook
 ```
 
 ## Building
 
 To build the book, type:
 
-```bash
+```
 $ mdbook build
 ```
 
 The output will be in the `book` subdirectory. To check it out, open it in
 your web browser.
 
 _Firefox:_
-```bash
+```
 $ firefox book/index.html           # Linux
 $ open -a "Firefox" book/index.html # OS X
 ```
 
 _Chrome:_
-```bash
+```
 $ google-chrome book/index.html           # Linux
 $ open -a "Google Chrome" book/index.html # OS X
 ```
 
 To run the tests:
 
-```bash
+```
 $ mdbook test
 ```
 

src/appendix-02-operators.md

@@ -174,7 +174,7 @@ Any such expression always has the `unit` type.
 The precedence of Rust binary operators is ordered as follows, going from
 strong to weak:
 
-```bash
+```text
 as :
 * / %
 + -

src/ch01-01-installation.md

@@ -16,14 +16,14 @@ with `$` are typically showing the output of the previous command.
 If you're on Linux or a Mac, all you need to do is open a terminal and type
 this:
 
-```bash
+```text
 $ curl https://sh.rustup.rs -sSf | sh
 ```
 
 This will download a script and start the installation. You may be prompted for
 your password. If it all goes well, you’ll see this appear:
 
-```bash
+```text
 Rust is installed now. Great!
 ```
 
@@ -48,22 +48,22 @@ installation page](https://www.rust-lang.org/install.html) for other options.
 Uninstalling Rust is as easy as installing it. From your shell, run
 the uninstall script:
 
-```bash
+```text
 $ rustup self uninstall
 ```
 
 ### Troubleshooting
 
 If you've got Rust installed, you can open up a shell, and type this:
 
-```bash
+```text
 $ rustc --version
 ```
 
 You should see the version number, commit hash, and commit date in a format
 similar to this for the latest stable version at the time you install:
 
-```bash
+```text
 rustc x.y.z (abcabcabc yyyy-mm-dd)
 ```
 

src/ch01-02-hello-world.md

@@ -19,7 +19,7 @@ the following commands to make a directory for this particular project:
 
 Linux and Mac:
 
-```bash
+```text
 $ mkdir ~/projects
 $ cd ~/projects
 $ mkdir hello_world
@@ -55,7 +55,7 @@ fn main() {
 Save the file, and go back to your terminal window. On Linux or OSX, enter the
 following commands:
 
-```bash
+```text
 $ rustc main.rs
 $ ./main
 Hello, world!
@@ -121,7 +121,7 @@ Before running a Rust program, you have to compile it. You can use the Rust
 compiler by entering the `rustc` command and passing it the name of your source
 file, like this:
 
-```bash
+```text
 $ rustc main.rs
 ```
 
@@ -130,7 +130,7 @@ If you come from a C or C++ background, you'll notice that this is similar to
 executable, which you can see on Linux or OSX by entering the `ls` command in
 your shell as follows:
 
-```bash
+```text
 $ ls
 main  main.rs
 ```
@@ -147,7 +147,7 @@ This shows we have two files: the source code, with the `.rs` extension, and the
 executable (`main.exe` on Windows, `main` everywhere else). All that's left to
 do from here is run the `main` or `main.exe` file, like this:
 
-```bash
+```text
 $ ./main  # or .\main.exe on Windows
 ```
 
@@ -189,7 +189,7 @@ itself, if you used the official installers as covered in the Installation
 chapter. If you installed Rust through some other means, you can check if you
 have Cargo installed by typing the following into your terminal:
 
-```bash
+```text
 $ cargo --version
 ```
 
@@ -205,7 +205,7 @@ decided to put your code):
 
 Linux and Mac:
 
-```bash
+```text
 $ cd ~/projects
 ```
 
@@ -217,7 +217,7 @@ Windows:
 
 And then on any operating system run:
 
-```bash
+```text
 $ cargo new hello_cargo --bin
 $ cd hello_cargo
 ```
@@ -304,15 +304,15 @@ Cargo by moving your code into the `src` directory and creating an appropriate
 Now let's look at what's different about building and running your Hello World
 program through Cargo! To do so, enter the following commands:
 
-```bash
+```text
 $ cargo build
    Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
 ```
 
 This should have created an executable file in `target/debug/hello_cargo` (or
 `target\debug\hello_cargo.exe` on Windows), which you can run with this command:
 
-```bash
+```text
 $ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
 Hello, world!
 ```
@@ -339,7 +339,7 @@ We just built a project with `cargo build` and ran it with
 `./target/debug/hello_cargo`, but we can also use `cargo run` to compile
 and then run:
 
-```bash
+```text
 $ cargo run
      Running `target/debug/hello_cargo`
 Hello, world!
@@ -351,7 +351,7 @@ it just ran the binary. If you had modified your source code, Cargo would have
 rebuilt the project before running it, and you would have seen something like
 this:
 
-```bash
+```text
 $ cargo run
    Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
      Running `target/debug/hello_cargo`
@@ -393,7 +393,7 @@ tooling you’ll use for the rest of your Rust career. In fact, you can get
 started with virtually all Rust projects you want to work
 on with the following commands:
 
-```bash
+```text
 $ git clone someurl.com/someproject
 $ cd someproject
 $ cargo build

src/ch02-00-guessing-game-tutorial.md

@@ -17,7 +17,7 @@ game will print congratulations and exit.
 To set up a new project, go to the *projects* directory that you created in
 Chapter 1, and make a new project using Cargo, like so:
 
-```bash
+```text
 $ cargo new guessing_game --bin
 $ cd guessing_game
 ```
@@ -57,7 +57,7 @@ fn main() {
 Now let’s compile this “Hello, world!” program and run it in the same step
 using the `cargo run` command:
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/debug/guessing_game`
@@ -281,7 +281,7 @@ entered into standard input.
 
 If we don’t call `expect`, the program will compile, but we’ll get a warning:
 
-```bash
+```text
 $ cargo build
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
 src/main.rs:10:5: 10:39 warning: unused result which must be used,
@@ -324,7 +324,7 @@ This code would print out `x = 5 and y = 10`.
 
 Let’s test the first part of the guessing game. You can run it using `cargo run`:
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/debug/guessing_game`
@@ -382,7 +382,7 @@ version 0.3.14.”
 Now, without changing any of the code, let’s build the project, as shown in
 Listing 2-2:
 
-```bash
+```text
 $ cargo build
     Updating registry `https://github.com/rust-lang/crates.io-index`
  Downloading rand v0.3.14
@@ -421,7 +421,7 @@ doesn't recompile that either. With nothing to do, it simply exits. If you open
 up the *src/main.rs* file, make a trivial change, then save it and build again,
 you’ll only see one line of output:
 
-```bash
+```text
 $ cargo build
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
 ```
@@ -464,7 +464,7 @@ But by default, Cargo will only look for versions larger than `0.3.0` and
 smaller than `0.4.0`. If the `rand` crate has released two new versions,
 `0.3.15` and `0.4.0`, you would see the following if you ran `cargo update`:
 
-```bash
+```text
 $ cargo update
     Updating registry `https://github.com/rust-lang/crates.io-index`
     Updating rand v0.3.14 -> v0.3.15
@@ -564,7 +564,7 @@ the answer as soon as it starts!
 
 Try running the program a few times:
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/debug/guessing_game`
@@ -675,7 +675,7 @@ look at the last arm in this particular scenario.
 
 However, the code in Listing 2-4 won’t compile yet. Let’s try it:
 
-```bash
+```text
 $ cargo build
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
 error[E0308]: mismatched types
@@ -793,7 +793,7 @@ and `expect` will return the number that we want from the `Ok` value.
 
 Let’s run the program now!
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/guessing_game`
@@ -868,7 +868,7 @@ the `parse` discussion in “Comparing the Guesses” on page XX: if the user
 enters a non-number answer, the program will crash. The user can take advantage
 of that in order to quit, as shown here:
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/guessing_game`
@@ -985,7 +985,7 @@ might encounter!
 Now everything in the program should work as expected. Let’s try it by running
 `cargo run`:
 
-```bash
+```text
 $ cargo run
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
      Running `target/guessing_game`

src/ch03-01-variables-and-mutability.md

@@ -27,7 +27,7 @@ fn main() {
 Save and run the program using `cargo run`. You should receive an error
 message, as shown in this output:
 
-```bash
+```text
 $ cargo run
    Compiling variables v0.0.1 (file:///projects/variables)
 error[E0384]: re-assignment of immutable variable `x`
@@ -82,7 +82,7 @@ fn main() {
 
 When we run this program, we get the following:
 
-```bash
+```text
 $ cargo run
    Compiling variables v0.1.0 (file:///projects/variables)
      Running `target/debug/variables`
@@ -166,7 +166,7 @@ repeating `let x =`, taking the original value and adding `1` so the value of
 previous value and multiplying it by `2` to give `x` a final value of `12`.
 When you run this program, it will output the following:
 
-```bash
+```text
 $ cargo run
    Compiling variables v0.1.0 (file:///projects/variables)
      Running `target/debug/variables`
@@ -204,7 +204,7 @@ spaces = spaces.len();
 we’ll get a compile-time error because we’re not allowed to mutate a variable’s
 type:
 
-```bash
+```text
 error[E0308]: mismatched types
  --> src/main.rs:3:14
   |

src/ch03-02-data-types.md

@@ -20,7 +20,7 @@ If we don’t add the type annotation here, Rust will display the following
 error, which means the compiler needs more information from us to know which
 possible type we want to use:
 
-```bash
+```text
 error[E0282]: unable to infer enough type information about `_`
  --> src/main.rs:2:5
   |
@@ -347,7 +347,7 @@ fn main() {
 
 Running this code using `cargo run` produces the following result:
 
-```bash
+```text
 $ cargo run
    Compiling arrays v0.1.0 (file:///projects/arrays)
      Running `target/debug/arrays`