s/boolean/Boolean/g

Author: carols10cents

second-edition/dictionary.txt

@@ -38,8 +38,8 @@ BitXor
 Bjarne
 Boehm
 bool
-boolean
-booleans
+Boolean
+Booleans
 Bors
 BorrowMutError
 BuildHasher

second-edition/src/appendix-01-keywords.md

@@ -17,7 +17,7 @@ or lifetimes.
 * `else` - fallback for `if` and `if let` control flow constructs
 * `enum` - defining an enumeration
 * `extern` - external crate, function, and variable linkage
-* `false` - boolean false literal
+* `false` - Boolean false literal
 * `fn` - function definition and function pointer type
 * `for` - iterator loop, part of trait impl syntax, and higher-ranked lifetime
   syntax
@@ -39,7 +39,7 @@ or lifetimes.
 * `struct` - structure definition
 * `super` - parent module of the current module
 * `trait` - trait definition
-* `true` - boolean true literal
+* `true` - Boolean true literal
 * `type` - type alias and associated type definition
 * `unsafe` - denotes unsafe code, functions, traits, and implementations
 * `use` - import symbols into scope

second-edition/src/appendix-02-operators.md

@@ -18,7 +18,7 @@ operators, before the expression they apply to.
     could mutate the dereference), and produces the result of dereferencing the
     `&` or `&mut` borrowed pointer returned from the overload method.
 * `!`
-  : Logical negation. On the boolean type, this flips between `true` and
+  : Logical negation. On the Boolean type, this flips between `true` and
     `false`. On integer types, this inverts the individual bits in the
     two’s complement representation of the value.
 * `&` and `&mut`
@@ -64,7 +64,7 @@ calculation; see the `pow` method on the numeric types.
 Like the arithmetic operators, bitwise operators are syntactic sugar for calls
 to methods of built-in traits. This means bitwise operators can be overridden
 for user-defined types. The default meaning of the operators on standard types
-is given here. Bitwise `&`, `|` and `^` applied to boolean arguments are
+is given here. Bitwise `&`, `|` and `^` applied to Boolean arguments are
 equivalent to logical `&&`, `||` and `!=` evaluated in non-lazy fashion.
 
 * `&`
@@ -83,9 +83,9 @@ equivalent to logical `&&`, `||` and `!=` evaluated in non-lazy fashion.
   : Right shift (arithmetic).
     Calls the `shr` method of the `std::ops::Shr` trait.
 
-#### Lazy boolean operators
+#### Lazy Boolean Operators
 
-The operators `||` and `&&` may be applied to operands of boolean type. The
+The operators `||` and `&&` may be applied to operands of Boolean type. The
 `||` operator denotes logical ‘or’, and the `&&` operator denotes logical
 ‘and’. They differ from `|` and `&` in that the right-hand operand is only
 evaluated when the left-hand operand does not already determine the result of

second-edition/src/ch03-02-data-types.md

@@ -36,7 +36,7 @@ You’ll see different type annotations as we discuss the various data types.
 ### Scalar Types
 
 A *scalar* type represents a single value. Rust has four primary scalar types:
-integers, floating-point numbers, booleans, and characters. You’ll likely
+integers, floating-point numbers, Booleans, and characters. You’ll likely
 recognize these from other programming languages, but let’s jump into how they
 work in Rust.
 
@@ -156,8 +156,8 @@ list of all operators that Rust provides.
 
 #### The Boolean Type
 
-As in most other programming languages, a boolean type in Rust has two possible
-values: `true` and `false`. The boolean type in Rust is specified using `bool`.
+As in most other programming languages, a Boolean type in Rust has two possible
+values: `true` and `false`. The Boolean type in Rust is specified using `bool`.
 For example:
 
 <span class="filename">Filename: src/main.rs</span>
@@ -170,7 +170,7 @@ fn main() {
 }
 ```
 
-The main way to consume boolean values is through conditionals, such as an `if`
+The main way to consume Boolean values is through conditionals, such as an `if`
 expression. We’ll cover how `if` expressions work in Rust in the “Control Flow”
 section.
 

second-edition/src/ch03-05-control-flow.md

@@ -102,9 +102,9 @@ error[E0308]: mismatched types
 ```
 
 The error indicates that Rust expected a `bool` but got an integer. Rust will
-not automatically try to convert non-boolean types to a boolean, unlike
+not automatically try to convert non-Boolean types to a Boolean, unlike
 languages such as Ruby and JavaScript. You must be explicit and always provide
-`if` with a `boolean` as its condition. If we want the `if` code block to run
+`if` with a Boolean as its condition. If we want the `if` code block to run
 only when a number is not equal to `0`, for example, we can change the `if`
 expression to the following:
 

second-edition/src/ch04-01-what-is-ownership.md

@@ -428,7 +428,7 @@ be sure, but as a general rule, any group of simple scalar values can be
 `Copy`. Here are some of the types that are `Copy`:
 
 * All the integer types, like `u32`.
-* The boolean type, `bool`, with values `true` and `false`.
+* The Boolean type, `bool`, with values `true` and `false`.
 * The character type, `char`.
 * All the floating point types, like `f64`.
 * Tuples, but only if they contain types that are also `Copy`. `(i32, i32)` is

second-edition/src/ch05-03-method-syntax.md

@@ -161,7 +161,7 @@ parameter will be by looking at the code that calls the method:
 read `rect2` (rather than write, which would mean we’d need a mutable borrow),
 and we want `main` to retain ownership of `rect2` so we can use it again after
 calling the `can_hold` method. The return value of `can_hold` will be a
-boolean, and the implementation will check whether the width and height of
+Boolean, and the implementation will check whether the width and height of
 `self` are both greater than the width and height of the other `Rectangle`,
 respectively. Let’s add the new `can_hold` method to the `impl` block from
 Listing 5-13, shown in Listing 5-15:

second-edition/src/ch06-02-match.md

@@ -43,7 +43,7 @@ the variants of the enum as its patterns.</span>
 Let’s break down the `match` in the `value_in_cents` function. First, we list
 the `match` keyword followed by an expression, which in this case is the value
 `coin`. This seems very similar to an expression used with `if`, but there’s a
-big difference: with `if`, the expression needs to return a boolean value.
+big difference: with `if`, the expression needs to return a Boolean value.
 Here, it can be any type. The type of `coin` in this example is the `Coin` enum
 that we defined in Listing 6-3.
 

second-edition/src/ch11-01-writing-tests.md

@@ -214,7 +214,7 @@ let’s look at some macros other than `panic!` that are useful in tests.
 
 The `assert!` macro, provided by the standard library, is useful when you want
 to ensure that some condition in a test evaluates to `true`. We give the
-`assert!` macro an argument that evaluates to a boolean. If the value is
+`assert!` macro an argument that evaluates to a Boolean. If the value is
 `true`, `assert!` does nothing and the test passes. If the value is `false`,
 the `assert!` macro calls the `panic!` macro, which causes the test to fail.
 Using the `assert!` macro helps us check that our code is functioning in the
@@ -243,7 +243,7 @@ impl Rectangle {
 <span class="caption">Listing 11-5: Using the `Rectangle` struct and its
 `can_hold` method from Chapter 5</span>
 
-The `can_hold` method returns a boolean, which means it’s a perfect use case
+The `can_hold` method returns a Boolean, which means it’s a perfect use case
 for the `assert!` macro. In Listing 11-6, we write a test that exercises the
 `can_hold` method by creating a `Rectangle` instance that has a length of 8 and
 a width of 7, and asserting that it can hold another `Rectangle` instance that

second-edition/src/ch12-05-working-with-environment-variables.md

@@ -147,7 +147,7 @@ pub struct Config {
 }
 ```
 
-We add the `case_sensitive` field that holds a boolean. Then we need our `run`
+We add the `case_sensitive` field that holds a Boolean. Then we need our `run`
 function to check the `case_sensitive` field’s value and use that to decide
 whether to call the `search` function or the `search_case_insensitive` function
 as shown in Listing 12-22:

second-edition/src/ch13-02-iterators.md

@@ -229,7 +229,7 @@ provides.
 Now that we’ve introduced iterators, we can demonstrate a common use of
 closures that capture their environment by using the `filter` iterator adapter.
 The `filter` method on an iterator takes a closure that takes each item from
-the iterator and returns a boolean. If the closure returns `true`, the value
+the iterator and returns a Boolean. If the closure returns `true`, the value
 will be included in the iterator produced by `filter`. If the closure returns
 `false`, the value won’t be included in the resulting iterator.