Can I use pattern matching on a dynamically constructed local tuple?

This example code doesn't compile:

record Thing(List<int> xs, List<int> ys);

	int DoStuff(Thing thing)
	{
 		return (thing.xs, thing.ys) switch
 		{
  			xs.Count > 5 => xs.First(),
  			ys.Count > 5 => ys.Last(),
  			xs.Count + ys.Count > 5 => xs.First()+ys.Last(),
  			(xs.Count > 0, ys.Count > 0) => Math.Max(xs.First(),ys.Last()),
  			_ => -1
 		}; 
	}

Does C# (.Net 6 or .Net 7) provide a syntax to do what I'm trying here or is this pushing the pattern matching syntax too far?

I thought I'd got somewhere using the {} syntax (relational patterns?) but this still doesn't work since capturing the return value is out of context.

return (thing.xs, thing.ys) switch
{
    {xs.Count: > 5} => xs.First(),
    {ys.Count: > 5} => ys.Last(),
    {xs.Count + ys.Count: > 5} => xs.First()+ys.Last(),
    {xs.Count: > 0 , ys.Count: > 0) => Math.Max(xs.First(),ys.Last()),
    _ => -1
}; 

It seems like I'm getting closer, but only by trial and error without really understanding the language syntax.

You could switch on a tuple containing the counts and use tuple patterns. (I renamed as and bs to a and b since as is a reserved keyword):

int DoStuff(Thing thing)
{
    return (thing.a.Count, thing.b.Count) switch {
        ( > 5, _) => thing.a.Count,
        (_, > 5) => thing.b.Count,
        _ when thing.a.Count + thing.b.Count > 5 => thing.a.Count + thing.b.Count,
        ( > 0, > 0) => Math.Max(thing.a.Count, thing.b.Count),
        _ => -1
    };
}

Note that the discard _ means "does not matter". As an example, the pattern ( > 5, _) means: The 1st item of the tuple (thing.a.Count) must be greater than 5 and the 2nd item (thing.b.Count) does not matter. I.e., if you switch on a tuple, you must use tuple patterns.

Since we cannot use an addition operation in a pattern, I used a when clause to introduce a standard Boolean condition.

A refinement of this approach is do create a named tuple for further simplification:

int DoStuff(Thing thing)
{
    var t = (ac: thing.a.Count, bc: thing.b.Count);
    return t switch {
        ( > 5, _) => t.ac,
        (_, > 5) => t.bc,
        _ when t.ac + t.bc > 5 => t.ac + t.bc,
        ( > 0, > 0) => Math.Max(t.ac, t.bc),
        _ => -1
    };
}

Yet another possibility is to use a positional pattern with nested property patterns. The positional pattern works because records generate a Deconstructor automatically. A record's deconstructor presents the elements in the same order as they are defined in the primary constructor. The record record Thing(List<int> a, List<int> b); generates this deconstructor:

public void Deconstruct(out List<int> a, out List<int> b)
{
    a = this.a;
    b = this.b;
}

With positional pattern:

int DoStuff2(Thing thing)
{
    return thing switch {
        ( { Count: > 5 }, _) => thing.a.Count,
        (_, { Count: > 5 }) => thing.b.Count,
        _ when thing.a.Count + thing.b.Count > 5 => thing.a.Count + thing.b.Count,
        ( { Count: > 0 }, { Count: > 0 }) => Math.Max(thing.a.Count, thing.b.Count),
        _ => -1
    };
}

This approach allows you to switch on any property and even on more than one property. Switching on thing these are valid patterns as well:

• ( { Count: > 5, Capacity: < 100 }, _)
• { a.Count: > 5 }
• { a.Count: > 0, b.Count: > 0 }
  or the same but with a positional pattern and nested list patterns
  ([_, ..], [_, ..])

So , there many different ways to formulate patterns.

See also: Pattern matching overview