S>Multiply(Constant(Type t, var x) e, _) when t.IsNumeric && Convert.ToDouble(x) == 0.0 => e,                                // 0 * e => 0
S>

Multiply(Constant(0.0) e,   _)               => e ..

[Test]
public void ConstantFoldingExTest2()
{
    Expression<Func<int,int>> f = i => i + 1 - 1 + 2 - i;

    Expr Transform<T>(Expr ex, Func<T,T,T> multiply, Func<T,T,T> divide, Func<T,T,T> add, Func<T,T,T> subst)
    {
        return ex switch
        {
            Multiply(Constant(T x), Constant(T y)) => Constant(multiply(x, y)), // x * y => e
            Divide  (Constant(T x), Constant(T y)) => Constant(divide  (x, y)), // x / y => e
            Add     (Constant(T x), Constant(T y)) => Constant(add     (x, y)), // x + y => e
            Subtract(Constant(T x), Constant(T y)) => Constant(subst   (x, y)), // x - y => e
            _                                      => null
        };
    };

    var f1 = f.TransformEx(ex => ex switch
    {
        Multiply(Constant(0) e,   _)               => e,               // 0 * e => 0
        Multiply(_,               Constant(0) e)   => e,               // e * 0 => 0
        Multiply(Constant(1),     var e)           => e,               // 1 * e => e
        Multiply(var e,           Constant(1))     => e,               // e * 1 => e
        Divide  (Constant(0) e,   _)               => e,               // 0 / e => 0
        Divide  (var e,           Constant(1))     => e,               // e / 1 => e
        Add     (Constant(0),     var e)           => e,               // 0 + e => e
        Add     (var e,           Constant(0))     => e,               // e + 0 => e
        Subtract(Constant(0),     var e)           => Negate(e),       // 0 - e => -e
        Subtract(var e,           Constant(0))     => e,               // e - 0 => e
        _ when Transform<int>   (ex, (x,y) => x * y, (x, y) => x / y, (x, y) => x + y, (x, y) => x - y) is Expr e => e,
        _ when Transform<long>  (ex, (x,y) => x * y, (x, y) => x / y, (x, y) => x + y, (x, y) => x - y) is Expr e => e,
        _ when Transform<double>(ex, (x,y) => x * y, (x, y) => x / y, (x, y) => x + y, (x, y) => x - y) is Expr e => e,
        _                                          => ex
    });

    Console.WriteLine(f);
    Console.WriteLine(f1);

    Assert.IsTrue(f1.EqualsTo(i => 2));
}

public static T Fold<T>(T expr)
    where T : notnull, LambdaExpression
{
    return expr.TransformEx<T>(FoldExpr);
}

public static Expression? Fold(Expression? expr)
{
    return expr.TransformEx(FoldExpr);
}

static Expr FoldExpr(Expr ex)
{
    return ex switch
    {
        Multiply(Constant(0) e,   _)               => e,                // 0 * e => 0
        Multiply(_,               Constant(0) e)   => e,                // e * 0 => 0
        Multiply(Constant(1),     var e)           => e,                // 1 * e => e
        Multiply(var e,           Constant(1))     => e,                // e * 1 => e
        Divide  (Constant(0) e,   _)               => e,                // 0 / e => 0
        Divide  (var e,           Constant(1))     => e,                // e / 1 => e
        Add     (Constant(0),     var e)           => e,                // 0 + e => e
        Add     (var e,           Constant(0))     => e,                // e + 0 => e
        Subtract(Constant(0),     var e)           => Negate(e)!,       // 0 - e => -e
        Subtract(var e,           Constant(0))     => e,                // e - 0 => e
        Multiply(Constant(int x), Constant(int y)) => Constant(x * y)!, // x * y => e
        Divide  (Constant(int x), Constant(int y)) => Constant(x / y)!, // x / y => e
        Add     (Constant(int x), Constant(int y)) => Constant(x + y)!, // x + y => e
        Subtract(Constant(int x), Constant(int y)) => Constant(x - y)!, // x - y => e

        Add     (Add     (Constant(int c1), var e), Constant(int c2)) => Fold(Add     (Constant(c1 + c2), e)),  // (c1 + e) + c2 = (c1 + e2) + e
        Multiply(Multiply(Constant(int c1), var e), Constant(int c2)) => Fold(Multiply(Constant(c1 * c2), e)),  // (c1 + e) + c2 = (c1 + e2) + e

        Add     (var e,           Constant c)      => Add     (c, e),            // e + c => c + e
        Multiply(var e,           Constant c)      => Multiply(c, e),            // e * c => c * e
        Subtract(var e,           Constant(int x)) => Add     (Constant(-x), e), // e - c => (-c) + e

        Add     (var e1,          Add     (var e2, var e3)) => Fold(Add     (Add     (e1, e2), e3)),  // e1 + (e2 + e3) = (e1 + e2) + e3
        Multiply(var e1,          Multiply(var e2, var e3)) => Fold(Multiply(Multiply(e1, e2), e3)),  // e1 + (e2 + e3) = (e1 + e2) + e3

        Subtract(Add(var e1, var e2), var e3) when e2 == e3 => e1,      // (e1 + e2) - e2 => e1

        _                                          => ex
    };
}

ARK>UPD. Правда, зачем мутабельными их сделали — это загадка, конечно. Как фсигда: вроде в целом неплохо, но обязательно что-то должно быть через очко. А у сектантов всегда есть оправдание любому говну.

Records are immutable by default.

ARK>UPD. Правда, зачем мутабельными их сделали — это загадка, конечно. Как фсигда: вроде в целом неплохо, но обязательно что-то должно быть через очко. А у сектантов всегда есть оправдание любому говну.

Records are specialized classes
As I just covered, the record and the class variants of LoginResource are almost identical. The class definition is a semantically identical subset of the record. The record provides more, specialized, behavior.

Just so we’re on the same page, the following comparison is between a record, and a class that uses init instead of set for properties, as demonstrated earlier.

What’s the same?

Construction
Immutability
Copy semantics (records are classes under the hood)
What’s different?

Record equality is based on content. Class equality based on object identity.
Records provide a GetHashCode() implementation is that is based on record content.
Records provide an IEquatable<T> implementation. It uses the unique GetHashCode() behavior as the mechanism to provide the content-based equality semantic for records.
Record ToString() is overridden to print record content.