boolean to Boolean (#2311)

Author: BNAndras

concepts/arrays/about.md

@@ -79,7 +79,7 @@ foreach (char vowel in vowels)
 A `for` loop does have some advantages over a `foreach` loop:
 
 - You can start or stop at the index you want.
-- You can use any (boolean) termination condition you want.
+- You can use any (Boolean) termination condition you want.
 - You can skip elements by customizing the incrementing of the loop variable.
 - You can process collections from back to front by counting down.
 - You can use `for` loops in scenarios that don't involve collections.

concepts/booleans/about.md

@@ -2,7 +2,7 @@
 
 Booleans in C# are represented by the `bool` type, which values can be either `true` or `false`.
 
-C# supports four [boolean operators][operators]: `!` (NOT), `&&` (AND),  `||` (OR), and `^` (XOR). The `&&` and `||` operators use _short-circuit evaluation_, which means that the right-hand side of the operator is only evaluated when needed.
+C# supports four [Boolean operators][operators]: `!` (NOT), `&&` (AND),  `||` (OR), and `^` (XOR). The `&&` and `||` operators use _short-circuit evaluation_, which means that the right-hand side of the operator is only evaluated when needed.
 
 ```csharp
 true || false // => true
@@ -11,7 +11,7 @@ true ^ false  // => true
 true ^ true   // => false
 ```
 
-The three boolean operators each have a different [_operator precedence_][precedence]. As a consequence, they are evaluated in this order: `not` first, `&&` second, `^` third, and finally `||`. If you want to 'escape' these rules, you can enclose a boolean expression in parentheses (`()`), as the parentheses have an even higher operator precedence.
+The three Boolean operators each have a different [_operator precedence_][precedence]. As a consequence, they are evaluated in this order: `not` first, `&&` second, `^` third, and finally `||`. If you want to 'escape' these rules, you can enclose a Boolean expression in parentheses (`()`), as the parentheses have an even higher operator precedence.
 
 ```csharp
 !true && false   // => false

concepts/booleans/introduction.md

@@ -2,4 +2,4 @@
 
 Booleans in C# are represented by the `bool` type, whose values can be either `true` or `false`.
 
-C# supports three boolean operators: `!` (NOT), `&&` (AND), and `||` (OR).
+C# supports three Boolean operators: `!` (NOT), `&&` (AND), and `||` (OR).

concepts/const-readonly/about.md

@@ -7,7 +7,7 @@ By default, values in C# are _mutable_, that is they can change over time. To ma
 
 The `const` modifier has some restrictions:
 
-1. It can only be applied to "constant" types: strings, booleans and numbers.
+1. It can only be applied to "constant" types: strings, Booleans and numbers.
 1. The `const` value must be initialized immediately.
 
 See [defining constants][defining-constants] for more information.

concepts/const-readonly/introduction.md

@@ -7,7 +7,7 @@ By default, values in C# are _mutable_, that is they can change over time. To ma
 
 The `const` modifier has some restrictions:
 
-1. It can only be applied to "constant" types: strings, booleans and numbers.
+1. It can only be applied to "constant" types: strings, Booleans and numbers.
 1. The `const` value must be initialized immediately.
 
 If your value is a non-constant type or you need to initialize the value in a constructor, `readonly` can be used to enforce immutability.

concepts/enums/about.md

@@ -40,7 +40,7 @@ enum Priority : byte
 
 ## Convert to an Enum member
 
-You should always consider using an enum whenever you want to model something like a boolean. Besides the aforementioned readability benefits, enums have another advantage over booleans: new values can always be added to an enum, whereas a boolean value will only ever be `true` or `false`. Using an enum is thus more future proof.
+You should always consider using an enum whenever you want to model something like a Boolean. Besides the aforementioned readability benefits, enums have another advantage over Booleans: new values can always be added to an enum, whereas a Boolean value will only ever be `true` or `false`. Using an enum is thus more future proof.
 
 ```csharp
 enum Status
@@ -71,7 +71,7 @@ Status status = (Status)Enum.Parse(typeof(Status), input);
 // Inactive
 ```
 
-To check if a name or a value exists in the enum, you can use [`Enum.TryParse`][enum tryparse] or [`Enum.IsDefined`][enum isdefined], both return a boolean indicating if the enum member exists:
+To check if a name or a value exists in the enum, you can use [`Enum.TryParse`][enum tryparse] or [`Enum.IsDefined`][enum isdefined], both return a Boolean indicating if the enum member exists:
 
 ```csharp
 bool doesExist = Enum.IsDefined(typeof(Status), "Inexistent");

concepts/exception-filtering/about.md

@@ -1,7 +1,7 @@
 # About
 
 `when` is the keyword in filtering exceptions. It is placed after the catch
-statement and can take a boolean expression containing any values in scope at the time. They don't just have to be members of the exception itself. If the type of the exception matches and the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.
+statement and can take a Boolean expression containing any values in scope at the time. They don't just have to be members of the exception itself. If the type of the exception matches and the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.
 
 ```csharp
 try

concepts/exception-filtering/introduction.md

@@ -1,7 +1,7 @@
 # Introduction
 
 `when` is the keyword in filtering exceptions. It is placed after the catch
-statement and can take a boolean expression containing any values in scope at the time. If the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.
+statement and can take a Boolean expression containing any values in scope at the time. If the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.
 
 ```csharp
 try

concepts/for-loops/.meta/config.json

@@ -1,5 +1,5 @@
 {
-  "blurb": "For-loops allow for iteration over a specified range, with a boolean condition to indicate when to stop, and an increment to indicate how much to go up or down by.",
+  "blurb": "For-loops allow for iteration over a specified range, with a Boolean condition to indicate when to stop, and an increment to indicate how much to go up or down by.",
   "authors": [
     "ErikSchierboom"
   ],

concepts/for-loops/about.md

@@ -42,7 +42,7 @@ foreach (char vowel in vowels)
 A `for` loop does have some advantages over a `foreach` loop:
 
 - You can start or stop at the index you want.
-- You can use any (boolean) termination condition you want.
+- You can use any (Boolean) termination condition you want.
 - You can skip elements by customizing the incrementing of the loop variable.
 - You can process collections from back to front by counting down.
 - You can use `for` loops in scenarios that don't involve collections.