Fix spelling from behaviour to behavior

Author: chorman0773

src/expressions.md

@@ -55,7 +55,7 @@ An expression *evaluates to* a value, and has effects during *evaluation*.
 r[expr.operands]
 Many expressions contain sub-expressions, called the *operands* of the expression.
 
-r[expr.behaviour]
+r[expr.behavior]
 The meaning of each kind of expression dictates several things:
 
 * Whether or not to evaluate the operands when evaluating the expression

src/expressions/array-expr.md

@@ -23,7 +23,7 @@ The first form lists out every value in the array.
 r[expr.array.array-syntax]
 The syntax for this form is a comma-separated list of expressions of uniform type enclosed in square brackets.
 
-r[expr.array.array-behaviour]
+r[expr.array.array-behavior]
 This produces an array containing each of these values in the order they are written.
 
 r[expr.array.repeat]
@@ -38,7 +38,7 @@ The expression after the `;` is called the *length operand*.
 r[expr.array.length-restriction]
 It must have type `usize` and be a [constant expression], such as a [literal] or a [constant item].
 
-r[expr.array.repeat-behaviour]
+r[expr.array.repeat-behavior]
 An array expression of this form creates an array with the length of the value of the length operand with each element being a copy of the repeat operand.
 That is, `[a; b]` creates an array containing `b` copies of the value of `a`.
 

src/expressions/match-expr.md

@@ -36,7 +36,7 @@ A `match` expression has a *[scrutinee] expression*, which is the value to compa
 r[expr.match.scrutinee-constraint]
 The scrutinee expression and the patterns must have the same type.
 
-r[expr.match.scrutinee-behaviour]
+r[expr.match.scrutinee-behavior]
 A `match` behaves differently depending on whether or not the scrutinee expression is a [place expression or value expression][place expression].
 
 r[expr.match.scrutinee-value]
@@ -111,7 +111,7 @@ Match arms can accept _match guards_ to further refine the criteria for matching
 r[expr.match.guard.type]
 Pattern guards appear after the pattern and consist of a `bool`-typed expression following the `if` keyword.
 
-r[expr.match.guard.behaviour]
+r[expr.match.guard.behavior]
 When the pattern matches successfully, the pattern guard expression is executed.
 If the expression evaluates to true, the pattern is successfully matched against.
 

src/expressions/operator-expr.md

@@ -205,7 +205,7 @@ The question mark operator (`?`) unwraps valid values or returns erroneous value
 r[expr.try.constraint]
 It is a unary postfix operator that can only be applied to the types `Result<T, E>` and `Option<T>`.
 
-r[expr.try.behaviour-std-result]
+r[expr.try.behavior-std-result]
 When applied to values of the `Result<T, E>` type, it propagates errors.
 
 r[expr.try.effects-err]
@@ -227,7 +227,7 @@ println!("{:?}", res);
 # assert!(res.is_err())
 ```
 
-r[expr.try.behaviour-std-option]
+r[expr.try.behavior-std-option]
 When applied to values of the `Option<T>` type, it propagates `None`s.
 
 r[expr.try.effects-none]
@@ -308,7 +308,7 @@ r[expr.arith-logic.syntax]
 r[expr.arith-logic.syntax]
 Binary operators expressions are all written with infix notation.
 
-r[expr.arith-logic.behaviour]
+r[expr.arith-logic.behavior]
 This table summarizes the behavior of arithmetic and logical binary operators on primitive types and which traits are used to overload these operators for other types.
 Remember that signed integers are always represented using two's complement.
 The operands of all of these operators are evaluated in [value expression context][value expression] so are moved or copied.
@@ -387,7 +387,7 @@ a == b;
 
 This means that the operands don't have to be moved out of.
 
-r[expr.cmp.behaviour]
+r[expr.cmp.behavior]
 
 | Symbol | Meaning                  | Overloading method         |
 |--------|--------------------------|----------------------------|
@@ -604,7 +604,7 @@ assert_eq!(values[1], 3);
 
 r[expr.as.pointer]
 
-r[expr.as.pointer.behaviour]
+r[expr.as.pointer.behavior]
 `*const T` / `*mut T` can be cast to `*const U` / `*mut U` with the following behavior:
 
 r[expr.as.pointer.sized]
@@ -638,10 +638,10 @@ An *assignment expression* moves a value into a specified place.
 r[expr.assign.assignee]
 An assignment expression consists of a [mutable] [assignee expression], the *assignee operand*, followed by an equals sign (`=`) and a [value expression], the *assigned value operand*.
 
-r[expr.assign.behaviour-basic]
+r[expr.assign.behavior-basic]
 In its most basic form, an assignee expression is a [place expression], and we discuss this case first.
 
-r[expr.assign.behaviour-destructring]
+r[expr.assign.behavior-destructring]
 The more general case of destructuring assignment is discussed below, but this case always decomposes into sequential assignments to place expressions, which may be considered the more fundamental case.
 
 ### Basic assignments
@@ -660,7 +660,7 @@ For destructuring assignment, subexpressions of the assignee expression are eval
 r[expr.assign.drop-target]
 It then has the effect of first [dropping] the value at the assigned place, unless the place is an uninitialized local variable or an uninitialized field of a local variable.
 
-r[expr.assign.behaviour]
+r[expr.assign.behavior]
 Next it either [copies or moves] the assigned value to the assigned place.
 
 r[expr.assign.result]

src/expressions/range-expr.md

@@ -30,7 +30,7 @@ r[expr.range.syntax]
 > _RangeToInclusiveExpr_ :\
 >    `..=` [_Expression_]
 
-r[expr.range.behaviour]
+r[expr.range.behavior]
 The `..` and `..=` operators will construct an object of one of the `std::ops::Range` (or `core::ops::Range`) variants, according to the following table:
 
 | Production             | Syntax        | Type                         | Range                 |

src/expressions/return-expr.md

@@ -10,7 +10,7 @@ r[expr.return.syntax]
 r[expr.return.intro]
 Return expressions are denoted with the keyword `return`.
 
-r[expr.return.behaviour]
+r[expr.return.behavior]
 Evaluating a `return` expression moves its argument into the designated output location for the current function call, destroys the current function activation frame, and transfers control to the caller frame.
 
 An example of a `return` expression: