The Insider News

public record class Cartesian(double x : X, double y : Y);    // Not really sure why they have x : X here!

public class Cartesian {
    private readonly double $X;
    private readonly double $Y;
    
    public Cartesian(double x, double y) { this.$X = x; this.$Y = y; }

    public double X { get { return this.$X; }
    public double Y { get { return this.$Y; }

    // pattern-is operator
    public static bool operator is (Cartesian c, out double x, out double y) { x = c.X; y = c.Y; return true; }

    // Also overrides object.Equals, object.GetHashCode and object.ToString() - all fairly obvious implementations.
}

var c = Cartesian(3, 4);

if (c is Cartesian(var x, y) {
    Console.WriteLine("c.X == " + x + ", c.Y == " + y);        // Note that x and y have been matched; this is called "deconstruction" in Haskell.
}

if (c is Cartesian(var x, *) {
    Console.WriteLine("c.X == " + x);
}

int? x;
...
if (x is int v) [
    // Use v here, confident it is not null.
}

abstract class Expr;
record class X() : Expr;
record class Const(double value) : Expr;
record class Add(Expr left, Expr right) : Expr;
record class Mult(Expr left, Expr right) : Expr;
record class Negate(Expr value) : Expr;

var expr = Add(Const(3.0), Negate(Mult(3, 5)));

Expr Simplify(Expr e) {
    switch (e) {
        case Mult(Const(0), *): return Const(0);
        case Mult(*, Const(0)): return Const(0);
        case Mult(Const(1), var x): return Simplify(x);    // Note recursive matching going on here!
        case Mult(var x, Const(1)): return Simplify(x);
        case Mult(Const(var l), Const(var r)): return Const(l * r);
        case Add(Const(0), var x): return Simplify(x);
        case Add(var x, Const(0): return Simplify(x);
        case Add(Const(var l), Const(var r)): return Const(l + r);
        case Negate(Const(var k)): return Const(-k);
        default: return e;
    }
}