funtional is in place.

docs/csharp/fundamentals/functional/deconstruct.md

@@ -6,64 +6,64 @@ ms.date: 03/22/2021
 ---
 # Deconstructing tuples and other types
 
-A tuple provides a lightweight way to retrieve multiple values from a method call. But once you retrieve the tuple, you have to handle its individual elements. Doing this on an element-by-element basis is cumbersome, as the following example shows. The `QueryCityData` method returns a 3-tuple, and each of its elements is assigned to a variable in a separate operation.
+A tuple provides a lightweight way to retrieve multiple values from a method call. But once you retrieve the tuple, you have to handle its individual elements. Working on an element-by-element basis is cumbersome, as the following example shows. The `QueryCityData` method returns a three-tuple, and each of its elements is assigned to a variable in a separate operation.
 
 :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple1.cs":::
 
-Retrieving multiple field and property values from an object can be equally cumbersome: you have to assign a field or property value to a variable on a member-by-member basis.
+Retrieving multiple field and property values from an object can be equally cumbersome: you must assign a field or property value to a variable on a member-by-member basis.
 
-Starting with C# 7.0, you can retrieve multiple elements from a tuple or retrieve multiple field, property, and computed values from an object in a single *deconstruct* operation. When you deconstruct a tuple, you assign its elements to individual variables. When you deconstruct an object, you assign selected values to individual variables.
+In C# 7.0 and later, you can retrieve multiple elements from a tuple or retrieve multiple field, property, and computed values from an object in a single *deconstruct* operation. To deconstruct a tuple, you assign its elements to individual variables. When you deconstruct an object, you assign selected values to individual variables.
 
 ## Deconstructing a tuple
 
-C# features built-in support for deconstructing tuples, which lets you unpackage all the items in a tuple in a single operation. The general syntax for deconstructing a tuple is similar to the syntax for defining one: you enclose the variables to which each element is to be assigned in parentheses in the left side of an assignment statement. For example, the following statement assigns the elements of a 4-tuple to four separate variables:
+C# features built-in support for deconstructing tuples, which lets you unpackage all the items in a tuple in a single operation. The general syntax for deconstructing a tuple is similar to the syntax for defining one: you enclose the variables to which each element is to be assigned in parentheses in the left side of an assignment statement. For example, the following statement assigns the elements of a four-tuple to four separate variables:
 
 ```csharp
 var (name, address, city, zip) = contact.GetAddressInfo();
 ```
 
 There are three ways to deconstruct a tuple:
 
-- You can explicitly declare the type of each field inside parentheses. The following example uses this approach to deconstruct the 3-tuple returned by the `QueryCityData` method.
+- You can explicitly declare the type of each field inside parentheses. The following example uses this approach to deconstruct the three-tuple returned by the `QueryCityData` method.
 
 :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple2.cs" ID="Snippet1":::
 
-- You can use the `var` keyword so that C# infers the type of each variable. You place the `var` keyword outside of the parentheses. The following example uses type inference when deconstructing the 3-tuple returned by the `QueryCityData` method.
+- You can use the `var` keyword so that C# infers the type of each variable. You place the `var` keyword outside of the parentheses. The following example uses type inference when deconstructing the three-tuple returned by the `QueryCityData` method.
 
     :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple3.cs" ID="Snippet1":::
 
     You can also use the `var` keyword individually with any or all of the variable declarations inside the parentheses.
 
     :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple4.cs" ID="Snippet1":::
 
-    This is cumbersome and is not recommended.
+    This is cumbersome and isn't recommended.
 
 - Lastly, you may deconstruct the tuple into variables that have already been declared.
 
     :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple5.cs" ID="Snippet1":::
 
-Note that you cannot specify a specific type outside the parentheses even if every field in the tuple has the
-same type. This generates compiler error CS8136, "Deconstruction 'var (...)' form disallows a specific type for 'var'.".
+You can't specify a specific type outside the parentheses even if every field in the tuple has the
+same type. Doing so generates compiler error CS8136, "Deconstruction 'var (...)' form disallows a specific type for 'var'.".
 
-Note that you must also assign each element of the tuple to a variable. If you omit any elements, the compiler generates error CS8132, "Cannot deconstruct a tuple of 'x' elements into 'y' variables."
+You must assign each element of the tuple to a variable. If you omit any elements, the compiler generates error CS8132, "Can't deconstruct a tuple of 'x' elements into 'y' variables."
 
-Note that you cannot mix declarations and assignments to existing variables on the left-hand side of a deconstruction. The compiler generates error CS8184, "a deconstruction cannot mix declarations and expressions on the left-hand-side." when the members include newly declared and existing variables.
+You can't mix declarations and assignments to existing variables on the left-hand side of a deconstruction. The compiler generates error CS8184, "a deconstruction can't mix declarations and expressions on the left-hand-side." when the members include newly declared and existing variables.
 
 ## Deconstructing tuple elements with discards
 
-Often when deconstructing a tuple, you're interested in the values of only some elements. Starting with C# 7.0, you can take advantage of C#'s support for *discards*, which are write-only variables whose values you've chosen to ignore. A discard is designated by an underscore character ("\_") in an assignment. You can discard as many values as you like; all are represented by the single discard, `_`.
+Often when deconstructing a tuple, you're interested in the values of only some elements. Starting with C# 7.0, you can take advantage of C#'s support for *discards*, which are write-only variables whose values you've chosen to ignore. A discard is chosen by an underscore character ("\_") in an assignment. You can discard as many values as you like; all are represented by the single discard, `_`.
 
-The following example illustrates the use of tuples with discards. The `QueryCityDataForYears` method returns a 6-tuple with the name of a city, its area, a year, the city's population for that year, a second year, and the city's population for that second year. The example shows the change in population between those two years. Of the data available from the tuple, we're unconcerned with the city area, and we know the city name and the two dates at design-time. As a result, we're only interested in the two population values stored in the tuple, and can handle its remaining values as discards.  
+The following example illustrates the use of tuples with discards. The `QueryCityDataForYears` method returns a six-tuple with the name of a city, its area, a year, the city's population for that year, a second year, and the city's population for that second year. The example shows the change in population between those two years. Of the data available from the tuple, we're unconcerned with the city area, and we know the city name and the two dates at design-time. As a result, we're only interested in the two population values stored in the tuple, and can handle its remaining values as discards.  
 
 :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple1.cs":::
 
 ## Deconstructing user-defined types
 
-C# does not offer built-in support for deconstructing non-tuple types other than the [`record`](#deconstructing-a-record-type) and [DictionaryEntry](xref:System.Collections.DictionaryEntry.Deconstruct%2A) types. However, as the author of a class, a struct, or an interface, you can allow instances of the type to be deconstructed by implementing one or more `Deconstruct` methods. The method returns void, and each value to be deconstructed is indicated by an [out](../../language-reference/keywords/out-parameter-modifier.md) parameter in the method signature. For example, the following `Deconstruct` method of a `Person` class returns the first, middle, and last name:
+C# doesn't offer built-in support for deconstructing non-tuple types other than the [`record`](#deconstructing-a-record-type) and [DictionaryEntry](xref:System.Collections.DictionaryEntry.Deconstruct%2A) types. However, as the author of a class, a struct, or an interface, you can allow instances of the type to be deconstructed by implementing one or more `Deconstruct` methods. The method returns void, and each value to be deconstructed is indicated by an [out](../../language-reference/keywords/out-parameter-modifier.md) parameter in the method signature. For example, the following `Deconstruct` method of a `Person` class returns the first, middle, and last name:
 
 :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple2.cs" ID="Snippet1":::
 
-You can then deconstruct an instance of the `Person` class named `p` with an assignment like the following:
+You can then deconstruct an instance of the `Person` class named `p` with an assignment like the following code:
 
 :::code language="csharp" source="./snippets/deconstructing-tuples/deconstruct-tuple3.cs" ID="Snippet1":::
 
@@ -89,7 +89,7 @@ The following example deconstructs a `Person` object into four strings (the firs
 
 If you didn't author a class, struct, or interface, you can still deconstruct objects of that type by implementing one or more `Deconstruct` [extension methods](../../programming-guide/classes-and-structs/extension-methods.md) to return the values in which you're interested.
 
-The following example defines two `Deconstruct` extension methods for the <xref:System.Reflection.PropertyInfo?displayProperty=nameWithType> class. The first returns a set of values that indicate the characteristics of the property, including its type, whether it's static or instance, whether it's read-only, and whether it's indexed. The second indicates the property's accessibility. Because the accessibility of get and set accessors can differ, Boolean values indicate whether the property has separate get and set accessors and, if it does, whether they have the same accessibility. If there is only one accessor or both the get and the set accessor have the same accessibility, the `access` variable indicates the accessibility of the property as a whole. Otherwise, the accessibility of the get and set accessors are indicated by the `getAccess` and `setAccess` variables.
+The following example defines two `Deconstruct` extension methods for the <xref:System.Reflection.PropertyInfo?displayProperty=nameWithType> class. The first returns a set of values that indicate the characteristics of the property, including its type, whether it's static or instance, whether it's read-only, and whether it's indexed. The second indicates the property's accessibility. Because the accessibility of get and set accessors can differ, Boolean values indicate whether the property has separate get and set accessors and, if it does, whether they have the same accessibility. If there's only one accessor or both the get and the set accessor have the same accessibility, the `access` variable indicates the accessibility of the property as a whole. Otherwise, the accessibility of the get and set accessors are indicated by the `getAccess` and `setAccess` variables.
 
 [!code-csharp[Extension-deconstruct](./snippets/deconstructing-tuples/deconstruct-extension1.cs)]
 

docs/csharp/fundamentals/functional/discards.md

@@ -1,10 +1,10 @@
 ---
-title: Discards - C# Guide
+title: Discards - unassigned discardable variables
 description: Describes C#'s support for discards, which are unassigned, discardable variables, and the ways in which discards can be used.
 ms.technology: csharp-fundamentals
-ms.date: 09/22/2020
+ms.date: 05/14/2021
 ---
-# Discards - C# Guide
+# Discards - C# Fundamentals
 
 Starting with C# 7.0, C# supports discards, which are placeholder variables that are intentionally unused in application code. Discards are equivalent to unassigned variables; they don't have a value. A discard communicates intent to the compiler and others that read your code: You intended to ignore the result of an expression. You may want to ignore the result of an expression, one or more members of a tuple expression, an `out` parameter to a method, or the target of a pattern matching expression.
 

docs/csharp/fundamentals/functional/pattern-matching.md

@@ -1,8 +1,7 @@
 ---
 title: Pattern matching overview - C# guide
 description: Learn about pattern matching expressions in C#
-ms.date: 04/26/2021
-ms.technology: csharp-fundamentals
+ms.date: 05/14/2021
 ---
 
 # Pattern matching overview
@@ -25,9 +24,9 @@ The preceding example used a [*constant pattern*](../../language-reference/opera
 
 ## Type tests
 
-Another common use for pattern matching is to test a variable to see if it matches a given type. For example, the following code tests if a variable is non-null and implements the <xref:System.IDisposable?displayProperty=nameWithType> interface. If it does, it calls the <xref:System.IDisposable.Dispose> method on that object. The declaration pattern doesn't match a `null` value, regardless of the compile-time type of the variable. The code below guards against `null`, in addition to guarding against a type that doesn't implement `IDisposable`.
+Another common use for pattern matching is to test a variable to see if it matches a given type. For example, the following code tests if a variable is non-null and implements the <xref:System.Collections.Generic.IList%601?displayProperty=nameWithType> interface. If it does, it calls the <xref:System.Collections.IList.Count?displayProperty=nameWithType> method on that list. The declaration pattern doesn't match a `null` value, regardless of the compile-time type of the variable. The code below guards against `null`, in addition to guarding against a type that doesn't implement `IList`.
 
-:::code language="csharp" source="snippets/patterns/Program.cs" ID="TypeCheckDisposable":::
+:::code language="csharp" source="snippets/patterns/Program.cs" ID="MidPoint":::
 
 The same tests can be applied in a `switch` expression to test a variable against multiple different types. You can use that information to create better algorithms based on the specific run-time type.
 
@@ -47,10 +46,12 @@ The preceding example shows the same algorithm, but uses string values instead o
 
 You can use [*relational patterns*](../../language-reference/operators/patterns.md#relational-patterns) to test how a value compares to constants. For example, the following code returns the state of water based on the temperature in Fahrenheit:
 
-:::code language="csharp" source="snippets/patterns/Simulation.cs" ID="RelationalPattern":::
+:::code language="csharp" source="snippets/patterns/Simulation.cs" ID="RelationalPattern" interactive="try-dotnet":::
 
 The preceding code also demonstrates the conjunctive `and` [*logical pattern*](../../language-reference/operators/patterns.md#logical-patterns) to check that both relational patterns match. You can also use a disjunctive `or` pattern to check that either pattern matches. The two relational patterns are surrounded by parentheses, which you can use around any pattern for clarity. The final two switch arms handle the cases for the melting point and the boiling point. Without those two arms, the compiler warns you that your logic doesn't cover every possible input.
 
+The preceding code also demonstrates another important feature the compiler provides for pattern matching expressions: The compiler warns you if you don't handle every input value. The compiler also issues a warning if a switch arm is already handled by a previous switch arm. That gives you freedom to refactor and reorder switch expressions. Try it yourself by refactoring the preceding code in the interactive window and see when the compiler issues warnings. You'll see squiggles under the code that has warnings.
+
 ## Multiple inputs
 
 All the patterns you've seen so far have been checking one input. You can write patterns that examine multiple properties of an object. Consider the following `Order` record:

docs/csharp/fundamentals/functional/snippets/patterns/OrderProcessor.cs

@@ -13,29 +13,29 @@ public record Order(int Items, decimal Cost);
     class OrderProcessor
     {
         // <PropertyPattern>
-        public double CalculateDiscount(Order order) =>
+        public decimal CalculateDiscount(Order order) =>
             order switch
             {
-                (Items: > 10, Cost: > 1000.00m) => 0.10,
-                (Items: > 5, Cost: > 500.00m) => 0.05,
-                Order { Cost: > 250.00m } => 0.02,
+                (Items: > 10, Cost: > 1000.00m) => 0.10m,
+                (Items: > 5, Cost: > 500.00m) => 0.05m,
+                Order { Cost: > 250.00m } => 0.02m,
                 null => throw new ArgumentNullException(nameof(order), "Can't calculate discount on null order"),
-                var o => 0,
+                var order => 0m,
             };
         // </PropertyPattern>
     }
 
     class OrderProcessing
     {
         // <DeconstructPattern>
-        public double CalculateDiscount(Order order) =>
+        public decimal CalculateDiscount(Order order) =>
             order switch
             {
-                ( > 10,  > 1000.00m) => 0.10,
-                ( > 5, > 50.00m) => 0.05,
-                Order { Cost: > 250.00m } => 0.02,
+                ( > 10,  > 1000.00m) => 0.10m,
+                ( > 5, > 50.00m) => 0.05m,
+                Order { Cost: > 250.00m } => 0.02m,
                 null => throw new ArgumentNullException(nameof(order), "Can't calculate discount on null order"),
-                var o => 0,
+                var order => 0m,
             };
         // </DeconstructPattern>
 

docs/csharp/fundamentals/functional/snippets/patterns/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace patterns
 {
@@ -10,21 +11,27 @@ static void Main(string[] args)
 
             NullReferenceCheck();
 
-            TypeCheckDisposable();
+            MidPointCheck();
         }
 
-        private static void TypeCheckDisposable()
+        // <MidPoint>
+        public static T MidPoint<T>(IEnumerable<T> sequence)
         {
-            object? heldReference = default;
-
-            // <TypeCheckDisposable>
-            if (heldReference is IDisposable disposable)
+            if (sequence is IList<T> list)
+            {
+                return list[list.Count / 2];
+            }
+            else if (sequence is null)
+            {
+                throw new ArgumentNullException(nameof(sequence), "Sequence can't be null.");
+            } else
             {
-                disposable.Dispose();
+                int halfLength = sequence.Count() / 2 - 1;
+                if (halfLength < 0) halfLength = 0;
+                return sequence.Skip(halfLength).First();
             }
-            heldReference = null;
-            // </TypeCheckDisposable>
         }
+        // </MidPoint>
 
         private static void NullReferenceCheck()
         {