Update the readme and the changelog

Author: TolikPylypchuk

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v3.1.0
+
+Whats's new in version 3.1.0:
+
+- .NET Standard 2.0 support was added back, but without nullable reference types
+- Matchmaker is now built with .NET 9
+- Trimming is now enabled only in .NET 6+
+
 ## v3.0.1
 
 Whats's new in version 3.0.1:

Matchmaker/README.md

@@ -10,7 +10,7 @@ Version 1.x can be found there. This package contains version 2+.
 
 This is what the simplest match expression looks like:
 
-```
+```c#
 using static Matchmaker.Patterns.Pattern;
 
 // ...
@@ -29,7 +29,7 @@ string result =
 
 This is what an equivalent `switch` statement looks like (pre-C# 8):
 
-```
+```c#
 string result;
 int i = 5;
 
@@ -65,13 +65,13 @@ in an object, and use it multiple times on different input values.
 - Like in `switch` the patterns are tried out sequentially. This means that the `Any` pattern should always
 come last.
 
-C# 8 included a new way to write `switch` expressions which yield a value, and C# 9 extended it quite a bit. This
-drastically reduced the need for external libraries like this one for pattern matching. However, this library lets the
-user define arbitrary patterns, which makes this library more powerful than the `switch` expressions.
+C# 8 included a new way to write `switch` expressions which yield a value, and further versions extended it quite a bit.
+This drastically reduced the need for external libraries like this one for pattern matching. However, this library lets
+the user define arbitrary patterns, which makes this library more powerful than the `switch` expressions.
 
-Here's what the equivalent switch expression looks like in C# 8:
+Here's what the equivalent switch expression looks like in C# 8 or later:
 
-```
+```c#
 int i = 5;
 
 string result = i switch
@@ -85,14 +85,14 @@ string result = i switch
 ```
 
 OK, this is much shorter and cleaner than the previous two examples. But this library shines when the patterns are
-more complex. While C# allowes various kinds of patterns, this library allows anything you can think about.
+more complex. While C# allows various kinds of patterns, this library allows anything you can think of.
 
 ## Another Example
 
 Let's define a simple list, implemented as [cons cells](https://en.wikipedia.org/wiki/Cons). This list is not
 generic for simplicity.
 
-```
+```c#
 public abstract class ConsList
 {
     private protected ConsList()
@@ -127,7 +127,7 @@ public sealed class Empty : ConsList
 Now let's look what pattern matching on the list would look like. Let's create
 a function which finds the sum of all items of the list.
 
-```
+```c#
 public int Sum(ConsList list) =>
     Match.Create<ConsList, int>()
         .Case<ConsCell>(cell => cell.Head + Sum(cell.Tail))
@@ -139,7 +139,7 @@ public int Sum(ConsList list) =>
 
 Here is the equivalent function implemented using the `switch` statement (pre-C# 8):
 
-```
+```c#
 public int Sum(ConsList list)
 {
     switch (list)
@@ -156,13 +156,13 @@ public int Sum(ConsList list)
 
 As you can see, we have to throw an exception in the `switch` version, because C# can't know that `ConsCell`
 and `Empty` are the only possible subclasses of `ConsList`. And for that reason, if we forget to define one
-of the cases in `switch` or in a match, we'll get an exception. In F# a warning is issued when the match is
+of the cases in `switch` or in a match, we'll get an exception. In F#, a warning is issued when the match is
 incomplete, but C# doesn't have the notion of complete or incomplete matches.
 
 With C# 8 there's a better way to do this, but we still have to explicitly throw an exception
 in the default case (which we know won't happen):
 
-```
+```c#
 public int Sum(ConsList list) =>
     list switch
     {
@@ -176,11 +176,11 @@ public int Sum(ConsList list) =>
 ## Matching with Fall-through
 
 C, C++ and, Java support fall-through in `switch` statements. So does this library, although it works differently here.
-You can read more [here](https://matchmaker.tolik.io/v3.0.0/articles/expressions.html#matching-with-fall-through).
+You can read more [here](https://matchmaker.tolik.io/articles/expressions.html#matching-with-fall-through).
 
 Here's an implementation of the famous fizz-buzz program which uses matching with fall-through:
 
-```
+```c#
 using System.Linq;
 
 using Matchmaker;
@@ -202,7 +202,8 @@ var result = Enumerable.Range(0, 15)
     .Select(items => items.Aggregate(String.Concat))
     .ToList();
 
-// The result is ("FizzBuzz", "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz");
+// The result is:
+// "FizzBuzz", "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"
 ```
 
 ## Static Match Expressions
@@ -211,7 +212,7 @@ One pain point of match expressions is that whenever a method which contains a m
 expression is initialized from scratch every time. This can be solved with static match expressions. Take a look at
 the revised simple example:
 
-```
+```c#
 string result = Match.CreateStatic<int, string>(match => match
         .Case(EqualTo(1), _ => "one")
         .Case(EqualTo(2), _ => "two")
@@ -222,29 +223,25 @@ string result = Match.CreateStatic<int, string>(match => match
 ```
 
 Now this match expression will be initialized only once even if its containing method is executed multiple times.
-You can read more [here](https://matchmaker.tolik.io/v3.0.0/articles/expressions.html#static-match-expressions).
+You can read more [here](https://matchmaker.tolik.io/articles/expressions.html#static-match-expressions).
 
 ## More Info
 
-If you want to learn how to use this library, you should read the [documentation](https://matchmaker.tolik.io/v3.0.0).
+If you want to learn how to use this library, you should read the [documentation](https://matchmaker.tolik.io).
 The articles provide everything you need to know to use this library.
 
-If you need extensive information, go to the [API reference](https://matchmaker.tolik.io/v3.0.0/api/index.html).
+If you need extensive information, go to the [API reference](https://matchmaker.tolik.io/api/index.html).
 
 If you need even more info about this library, you can go through the
-[tests](https://github.com/TolikPylypchuk/Matchmaker/tree/v3.0.0/Matchmaker.Tests). They are property-based and as such
+[tests](https://github.com/TolikPylypchuk/Matchmaker/Matchmaker.Tests). They are property-based and as such
 they describe every aspect of the classes and their members.
 
 ## Is This Library Still Maintained?
 
-I'm not planning on writing new versions beyond 3.0 (or maybe 3.1 if some stuff needs fixing). To be fair, I thought
+I'm not planning on writing new versions beyond 3.1 (or maybe 3.2 if some stuff needs fixing). To be fair, I thought
 the same thing after releasing version 1.1 and yet here we are. This time I do believe that this library has enough
-features (probably more than enough). Maybe one day I'll revisit this decision, but for now (January 2022) this is it;
+features (probably more than enough). Maybe one day I'll revisit this decision, but for now (June 2025) this is it;
 this is as good as it gets.
 
 That said, if you report a bug or request a new feature, I'll definitely look into it. I'm not giving up on this
 library any time soon.
-
-## License
-
-[MIT License](https://github.com/TolikPylypchuk/Matchmaker/blob/master/LICENSE)

README.md

@@ -10,23 +10,15 @@ Version 1.x can be found there. This repository contains version 2+.
 
 ## Installation
 
-If your platform supports .NET Standard 2.1, you can install the latest version:
-
-```
-dotnet add package Matchmaker --version 3.0.1
-```
-
-If it doesn't, then stick to versions 2.x:
-
 ```
-dotnet add package Matchmaker --version 2.1.0
+dotnet add package Matchmaker
 ```
 
 ## A Simple Example
 
 This is what the simplest match expression looks like:
 
-```
+```c#
 using static Matchmaker.Patterns.Pattern;
 
 // ...
@@ -45,7 +37,7 @@ string result =
 
 This is what an equivalent `switch` statement looks like (pre-C# 8):
 
-```
+```c#
 string result;
 int i = 5;
 
@@ -81,13 +73,13 @@ in an object, and use it multiple times on different input values.
 - Like in `switch` the patterns are tried out sequentially. This means that the `Any` pattern should always
 come last.
 
-C# 8 included a new way to write `switch` expressions which yield a value, and C# 9 extended it quite a bit. This
-drastically reduced the need for external libraries like this one for pattern matching. However, this library lets the
-user define arbitrary patterns, which makes this library more powerful than the `switch` expressions.
+C# 8 included a new way to write `switch` expressions which yield a value, and further versions extended it quite a bit.
+This drastically reduced the need for external libraries like this one for pattern matching. However, this library lets
+the user define arbitrary patterns, which makes this library more powerful than the `switch` expressions.
 
-Here's what the equivalent switch expression looks like in C# 8:
+Here's what the equivalent switch expression looks like in C# 8 or later:
 
-```
+```c#
 int i = 5;
 
 string result = i switch
@@ -101,14 +93,14 @@ string result = i switch
 ```
 
 OK, this is much shorter and cleaner than the previous two examples. But this library shines when the patterns are
-more complex. While C# allowes various kinds of patterns, this library allows anything you can think about.
+more complex. While C# allows various kinds of patterns, this library allows anything you can think of.
 
 ## Another Example
 
 Let's define a simple list, implemented as [cons cells](https://en.wikipedia.org/wiki/Cons). This list is not
 generic for simplicity.
 
-```
+```c#
 public abstract class ConsList
 {
     private protected ConsList()
@@ -143,7 +135,7 @@ public sealed class Empty : ConsList
 Now let's look what pattern matching on the list would look like. Let's create
 a function which finds the sum of all items of the list.
 
-```
+```c#
 public int Sum(ConsList list) =>
     Match.Create<ConsList, int>()
         .Case<ConsCell>(cell => cell.Head + Sum(cell.Tail))
@@ -155,7 +147,7 @@ public int Sum(ConsList list) =>
 
 Here is the equivalent function implemented using the `switch` statement (pre-C# 8):
 
-```
+```c#
 public int Sum(ConsList list)
 {
     switch (list)
@@ -172,13 +164,13 @@ public int Sum(ConsList list)
 
 As you can see, we have to throw an exception in the `switch` version, because C# can't know that `ConsCell`
 and `Empty` are the only possible subclasses of `ConsList`. And for that reason, if we forget to define one
-of the cases in `switch` or in a match, we'll get an exception. In F# a warning is issued when the match is
+of the cases in `switch` or in a match, we'll get an exception. In F#, a warning is issued when the match is
 incomplete, but C# doesn't have the notion of complete or incomplete matches.
 
 With C# 8 there's a better way to do this, but we still have to explicitly throw an exception
 in the default case (which we know won't happen):
 
-```
+```c#
 public int Sum(ConsList list) =>
     list switch
     {
@@ -192,11 +184,11 @@ public int Sum(ConsList list) =>
 ## Matching with Fall-through
 
 C, C++ and, Java support fall-through in `switch` statements. So does this library, although it works differently here.
-You can read more [here](https://matchmaker.tolik.io/v3.0.1/articles/expressions.html#matching-with-fall-through).
+You can read more [here](https://matchmaker.tolik.io/articles/expressions.html#matching-with-fall-through).
 
 Here's an implementation of the famous fizz-buzz program which uses matching with fall-through:
 
-```
+```c#
 using System.Linq;
 
 using Matchmaker;
@@ -218,7 +210,8 @@ var result = Enumerable.Range(0, 15)
     .Select(items => items.Aggregate(String.Concat))
     .ToList();
 
-// The result is ("FizzBuzz", "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz");
+// The result is:
+// "FizzBuzz", "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"
 ```
 
 ## Static Match Expressions
@@ -227,7 +220,7 @@ One pain point of match expressions is that whenever a method which contains a m
 expression is initialized from scratch every time. This can be solved with static match expressions. Take a look at
 the revised simple example:
 
-```
+```c#
 string result = Match.CreateStatic<int, string>(match => match
         .Case(EqualTo(1), _ => "one")
         .Case(EqualTo(2), _ => "two")
@@ -238,37 +231,31 @@ string result = Match.CreateStatic<int, string>(match => match
 ```
 
 Now this match expression will be initialized only once even if its containing method is executed multiple times.
-You can read more [here](https://matchmaker.tolik.io/v3.0.1/articles/expressions.html#static-match-expressions).
+You can read more [here](https://matchmaker.tolik.io/articles/expressions.html#static-match-expressions).
 
 ## More Info
 
-If you want to learn how to use this library, you should read the [documentation](https://matchmaker.tolik.io/v3.0.1).
+If you want to learn how to use this library, you should read the [documentation](https://matchmaker.tolik.io).
 The articles provide everything you need to know to use this library.
 
-If you need extensive information, go to the [API reference](https://matchmaker.tolik.io/v3.0.1/api/index.html).
+If you need extensive information, go to the [API reference](https://matchmaker.tolik.io/api/index.html).
 
 If you need even more info about this library, you can go through the
-[tests](https://github.com/TolikPylypchuk/Matchmaker/tree/v3.0.1/Matchmaker.Tests). They are property-based and as such
+[tests](https://github.com/TolikPylypchuk/Matchmaker/Matchmaker.Tests). They are property-based and as such
 they describe every aspect of the classes and their members.
 
-The documentation can be found here:
-
-- Version 3.0.1: https://matchmaker.tolik.io/v3.0.1
-- Version 3.0.0: https://matchmaker.tolik.io/v3.0.0
-- Version 2.1.0: https://matchmaker.tolik.io/v2.1.0
-- Version 2.0.0: https://matchmaker.tolik.io/v2.0.0
-- Older versions: https://github.com/TolikPylypchuk/PatternMatching
-
 ## Is This Library Still Maintained?
 
-I'm not planning on writing new versions beyond 3.0 (or maybe 3.1 if some stuff needs fixing). To be fair, I thought
+I'm not planning on writing new versions beyond 3.1 (or maybe 3.2 if some stuff needs fixing). To be fair, I thought
 the same thing after releasing version 1.1 and yet here we are. This time I do believe that this library has enough
-features (probably more than enough). Maybe one day I'll revisit this decision, but for now (January 2022) this is it;
+features (probably more than enough). Maybe one day I'll revisit this decision, but for now (June 2025) this is it;
 this is as good as it gets.
 
 That said, if you report a bug or request a new feature, I'll definitely look into it. I'm not giving up on this
 library any time soon.
 
-## License
+## Icon
 
-[MIT License](https://github.com/TolikPylypchuk/Matchmaker/blob/master/LICENSE)
+Icon made by [Roundicons](https://www.flaticon.com/authors/roundicons) from
+[www.flaticon.com](https://www.flaticon.com) and is licensed by
+[CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/).