Relational, logical and list patterns

A cold-room sensor reports 75.0 °C. The room should stay from 2 to 8 degrees and the sensor cannot measure above 60, so the reading is a fault, not a temperature. The test that flags it is one line of relational and logical patterns, and one pair of brackets decides whether it works.

Patterns can also test the shape of a sequence: how many arguments a command has, and which word comes first.

Relational and logical patterns compare with constants and combine tests

< 2 and <= 8 are relational patterns, met in the lesson on switch: they compare the value with a constant of a numeric, char or enum type. Logical patternslogical pattern: A pattern built from other patterns with and, or and not, such as >= 2 and <= 8 or not null, added in C# 9. not binds first, then and, then or; brackets change the grouping., added in C# 9 with relational ones, combine other patterns: and needs both to match, or either, and not turns a match into a miss. coldroom.cs sorts eight readings into bands, then tests each one for a fault twice, with brackets and without:

// Readings in degrees Celsius from a cold-room sensor. Relational patterns sort them into bands; logical patterns
// flag readings the sensor cannot really produce. The room should stay from 2 to 8; the sensor measures -30 to 60.
double[] readings = [4.2, 2.0, 1.5, 9.1, 12.0, -0.5, 75.0, double.NaN];

foreach (double celsius in readings)
{
    Console.WriteLine($"{celsius,5}  {Band(celsius),-10}  fault: {Fault(celsius),-5}  fault, written without brackets: {FaultSlip(celsius)}");
}

static string Band(double celsius) => celsius switch
{
    double.NaN => "no reading",
    < 0 => "freezing",
    < 2 => "too cold",
    <= 8 => "in range",
    <= 10 => "warm",
    _ => "too warm",
};

// A reading outside the sensor's range is a fault, not a temperature.
static bool Fault(double celsius) => celsius is not (>= -30.0 and <= 60.0);

// The same test without brackets: not binds to >= -30.0 alone, so this means (< -30.0 or NaN) and <= 60.0.
static bool FaultSlip(double celsius) => celsius is not >= -30.0 and <= 60.0;

  4.2  in range    fault: False  fault, written without brackets: False
    2  in range    fault: False  fault, written without brackets: False
  1.5  too cold    fault: False  fault, written without brackets: False
  9.1  warm        fault: False  fault, written without brackets: False
   12  too warm    fault: False  fault, written without brackets: False
 -0.5  freezing    fault: False  fault, written without brackets: False
   75  too warm    fault: True   fault, written without brackets: False
  NaN  no reading  fault: True   fault, written without brackets: False

Read the bands from the top. Every arm names only where its band ends, since whatever lies below that end was already taken by an arm above, so 2.0 fell into <= 8 and printed in range. NaN needed its own arm, double.NaN, a constant pattern, because a relational pattern never matches NaN. The two fault columns disagree on two readings, 75.0 and NaN.

The cause is how the combinators group. The C# reference gives the order: not binds first, then and, then or. Without brackets, not >= -30.0 and <= 60.0 means (not >= -30.0) and <= 60.0, which is not the range test it looks like. Step through both groupings for the two readings they disagree on:

One more rule follows from or and not: a pattern under them cannot declare a variable, error CS8780, because the compiler could not tell whether it was assigned. The single exception is the one met in the first lesson, is not string text as the whole pattern of an is.

A list pattern matches a sequence by its length and its elements

A list patternlist pattern: A pattern in square brackets, such as ["add", var item], that matches a sequence of that length element by element (C# 11). The compile-time type needs a Length or Count and an indexer., added in C# 11, is a list of patterns in square brackets. ["add", var item] matches a sequence of exactly two elements whose first is "add", and names the second. [] matches an empty sequence, and a slice patternslice pattern: The pattern .. inside a list pattern, at most once, standing for any number of elements, as in [first, .., last]. Followed by var or another pattern, it captures those elements as a slice., .., stands for any number of elements, at most once per list pattern. commands.cs reads the arguments of a shopping-list tool:

// The arguments of a shopping-list tool, matched by their shape with list patterns: how many there are, and what
// stands at each position.
string[][] calls =
[
    ["add", "mango"],
    ["add", "rice", "5", "kg"],
    ["remove", "mango"],
    ["list"],
    [],
    ["remove"],
    ["clear", "--yes"],
];

foreach (string[] call in calls)
{
    Console.WriteLine($"{Show(call),-27} {Describe(call)}");
}

static string Describe(string[] args) => args switch
{
    [] => "no command: print the help",
    ["add", var item] => $"add {item}",
    ["add", var item, .. var details] => $"add {item}, with {details.Length} more words: {string.Join(' ', details)}",
    ["remove", var item] => $"remove {item}",
    ["list"] => "list everything",
    [var command, ..] => $"unknown or incomplete: {command}",
};

static string Show(string[] args) => "[" + string.Join(", ", args.Select(a => $"\"{a}\"")) + "]";

["add", "mango"]            add mango
["add", "rice", "5", "kg"]  add rice, with 2 more words: 5 kg
["remove", "mango"]         remove mango
["list"]                    list everything
[]                          no command: print the help
["remove"]                  unknown or incomplete: remove
["clear", "--yes"]          unknown or incomplete: clear

Each call took the first arm whose shape fitted. ["add", "rice", "5", "kg"] was too long for ["add", var item], so it reached the arm with a slice, where .. var details captured the last two words. ["remove"] was too short for ["remove", var item] and fell to [var command, ..], which accepts any call with at least one word. Step through the long add call:

List patterns work on arrays, List<T>, strings and spans: any type whose compile-time type has a Length or Count and an indexer. An IEnumerable<T> alone does not qualify, because the pattern reads positions instead of enumerating, and capturing a slice with var also needs a range indexer or a Slice method.

Two questions build on this: which values a set of number ranges leaves uncovered, which the compiler can name for you, and what a captured slice costs on strings, arrays and spans.

Gaps in number ranges: what the compiler names, and the slip it cannot see Pro: opens with a Pro, Premium or Ultimate pass

Parsing with list patterns on strings and spans, with allocations measured Pro: opens with a Pro, Premium or Ultimate pass

Practise: relational, logical and list patterns

Practise the three kinds of pattern below. Every choice says why it is right or wrong, and the kind you are least sure of is asked about first:

Interview questions

Fresher · What do the and, or and not patterns do, and in what order do they apply?

They combine patterns, added in C# 9 with relational patterns: and matches when both patterns match, or when either does, and not when its pattern does not. They bind in that order of strength, not first, then and, then or, so x is not >= 10 and <= 20 means (not >= 10) and <= 20, which is not a range test. Use brackets to group, as in x is not (>= 10 and <= 20). Unlike && and ||, they combine patterns, not Boolean expressions, and a variable cannot be declared under or.

Key takeaways

• Relational patterns compare with a constant, and each arm of a band switch states only its top; NaN needs its own double.NaN arm.
• not binds before and, which binds before or, so brackets decide what a not covers.
• A list pattern tests a sequence’s length and its elements by position, with one optional slice, .., for the elements in between.
• List patterns need a Length or Count and an indexer on the compile-time type, so arrays, lists, strings and spans qualify and a plain IEnumerable<T> does not.