Out Parameter Pattern Matching

[SK-Genius]

Allow pattern matching on the out parameter of methods and extension methods, if the expression returns a bool.

Example

enum Op {
  Num, Neg, Add, Sub
}

sealed class Node {
  Op op;
  Node n1;
  Node n2;
  int val;

  static Node Num(int val) => new Node { op = Op.Num, val = val };
  static Node Neg(Node n) => new Node { op = Op.Neg, n1 = n1 };
  static Node Add(Node n1, Node n2) => new Node { op = Op.Add, n1 = n1, n2 = n2 };
  static Node Sub(Node n1, Node n2) => new Node { op = Op.Sub, n1 = n1, n2 = n2 };

  bool IsNum(out int val) {
      val = this.Val;
      return this.op == Op.Num;
  }

  bool IsNeg(out Node n) {
    n = this.n1;
    return this.op == Op.Neg;
  }

  bool IsAdd(out Node n1, out Node n2) {
    n1 = this.n1;
    n2 = this.n2;
    return this.op == Op.Add;
  }

  bool IsSub(out Node n1, out Node n2) {
    n1 = this.n1;
    n2 = this.n2;
    return this.op == Op.Sub;
  }
}

static class NodeExt {
  Node Simplify(this Node n) {
    if (n.IsAdd(out is null, out var _)) return null;
    if (n.IsAdd(out == 0, out var n)) return n.Simplify();
    if (n.IsAdd(out var n_, out == n_)) return Node.Mul(Node.Num(2), n_);
    if (n.IsAdd(out .IsNum(out var x), out.IsSub(out == x, out var n_))) return n_;
//  lowering to:
//  if (
//    n.IsAdd(out var _t1_, out var _t2_) &&
//    _t1_.IsNum(out var x) &&
//    _t2_.IsSub(out var _t3_, out var n_) &&
//    _t3_ == x
//  ) return n_;

    [...]
    return n;
  }
}

Pro

• less named local variables
• inline/recursive pattern matching
• works with int.TryParse(...) and co (int.TryParse("abc", out >= 0))

Alternative Syntax

use keyword is and is not instead of out:

if (n is Add(is Num(out var x), is Sub(is not != x, out var n_))) return n_;

or the combination out is and out is not:

if (n is Add(out is Num(out var x), out is Sub(out is not != x, out var n_))) return n_;

then you can also allow:

if (int.TryParse(out var x is > 0)) { ... }
// lowering to:
// if (int.TryParse(out var x) && x > 0) { ... }

[SK-Genius]

Some similar approach:

• Named deconstructors that can fail. (Named deconstructors that can fail. #4818)