typo: Double word "the"

meetings/2017/LDM-2017-05-31.md

@@ -90,7 +90,7 @@ You need to get into weird-ish stuff like this:
 base(I3).(I1.M1)<string>(1, 2, 3); // Call I3's implementation of I1's M1
 ```
 
-If we want to do something like this, we would also consider allowing *classes* to pick which one they grab the implementation from: even though classes have no ambiguity about which is the the most *specific* override, you could potentially allow "reaching around" and grabbing an older one.
+If we want to do something like this, we would also consider allowing *classes* to pick which one they grab the implementation from: even though classes have no ambiguity about which is the most *specific* override, you could potentially allow "reaching around" and grabbing an older one.
 
 ## Deimplementation
 

proposals/csharp-7.2/readonly-ref.md

@@ -258,7 +258,7 @@ The life time of the argument temporaries matches the closest encompassing scope
 The formal life time of temporary variables is semantically significant in scenarios involving escape analysis of variables returned by reference.
 
 ### Metadata representation of `in` parameters.
-When `System.Runtime.CompilerServices.IsReadOnlyAttribute` is applied to a byref parameter, it means that the the parameter is an `in` parameter.
+When `System.Runtime.CompilerServices.IsReadOnlyAttribute` is applied to a byref parameter, it means that the parameter is an `in` parameter.
 
 In addition, if the method is *abstract* or *virtual*, then the signature of such parameters (and only such parameters) must have `modreq[System.Runtime.InteropServices.InAttribute]`.
 
@@ -442,7 +442,7 @@ readonly struct Vector3
 **Motivation:** consequence of restriction on instance fields.
 
 ### Metadata representation.
-When `System.Runtime.CompilerServices.IsReadOnlyAttribute` is applied to a value type, it means that the the type is a `readonly struct`.
+When `System.Runtime.CompilerServices.IsReadOnlyAttribute` is applied to a value type, it means that the type is a `readonly struct`.
 
 In particular:
 -  The identity of the `IsReadOnlyAttribute` type is unimportant. In fact it can be embedded by the compiler in the containing assembly if needed.

proposals/records.md

@@ -252,7 +252,7 @@ See [the pattern-matching specification](csharp-8.0/patterns.md#positional-patte
 
 Unless there is a user-declared member named `With` declared, a record type has a compiler-provided method named `With` whose return type is the record type itself, and containing one value parameter corresponding to each *record-parameter* in the same order that these parameters appear in the record type declaration. Each parameter shall have a *caller-receiver default-argument* of the corresponding property.
 
-In an `abstract` record class, the compiler-provided `With` method is abstract. In a record struct, or a sealed record class, the compiler-provided `With` method is `sealed`. Otherwise the compiler-provided `With` method is `virtual and its implementation shall return a new instance produced by invoking the the primary constructor with the parameters as arguments to create a new instance from the parameters, and return that new instance.
+In an `abstract` record class, the compiler-provided `With` method is abstract. In a record struct, or a sealed record class, the compiler-provided `With` method is `sealed`. Otherwise the compiler-provided `With` method is `virtual and its implementation shall return a new instance produced by invoking the primary constructor with the parameters as arguments to create a new instance from the parameters, and return that new instance.
 
 - [ ] **Open issue**: We should also specify under what conditions we override or implement inherited virtual `With` methods or `With` methods from implemented interfaces.
 - [ ] **Open issue**: We should say what happens when we inherit a non-virtual `With` method.

spec/variables.md

@@ -566,7 +566,7 @@ For an expression *expr* of the form `expr_first ?? expr_second`:
 *  The definite assignment state of *v* before *expr_first* is the same as the definite assignment state of *v* before *expr*.
 *  The definite assignment state of *v* before *expr_second* is the same as the definite assignment state of *v* after *expr_first*.
 *  The definite assignment statement of *v* after *expr* is determined by:
-    * If *expr_first* is a constant expression ([Constant expressions](expressions.md#constant-expressions)) with value null, then the the state of *v* after *expr* is the same as the state of *v* after *expr_second*.
+    * If *expr_first* is a constant expression ([Constant expressions](expressions.md#constant-expressions)) with value null, then the state of *v* after *expr* is the same as the state of *v* after *expr_second*.
 *  Otherwise, the state of *v* after *expr* is the same as the definite assignment state of *v* after *expr_first*.
 
 #### ?: (conditional) expressions