single match {case _:MySingleton.type => println("OK")}

M>>>>[{elem1, elem2}|T]
M>>>>

M>>>>data.matches(list(elem1, elem2), T)
M>>>>

SR>>>Tail T = new Tail();
SR>>>class Tail {
SR>>>  public object[] value;
SR>>>}
SR>>>

SR>>>new Object[] {_, 2, x}
SR>>>

rational n + rational m -> rational(n + m)
rational n * rational m -> rational(n * m)
symbol x -> symbol x
0+f -> f
f+0 -> f
0*f -> 0
f*0 -> 0
1*f -> f
f*1 -> f
a+(b+c) -> (a+b)+c
a*(b*c) -> (a*b)*c

-module(rewrite).
-export([rewrite/1]).

rewrite({sum, N, M}) when is_number(N), is_number(M)
  -> N + M;
rewrite({mul, N, M}) when is_number(N), is_number(M)
  -> N * M;
rewrite(A) when is_atom(A)
  -> A;
rewrite({sum, 0, F})
  -> rewrite(F);
rewrite({sum, F, 0})
  -> rewrite(F);
rewrite({mul, 0, _})
  -> 0;
rewrite({mul, _, 0})
  -> 0;
rewrite({mul, 1, F})
  -> rewrite(F);
rewrite({mul, F, 1})
  -> rewrite(F);
rewrite({sum, A, {sum, B, C}})
  -> rewrite({sum, {sum, A, B}, C});
rewrite({mul, A, {mul, B, C}})
  -> rewrite({mul, {mul, A, B}, C});

rewrite(N) when is_number(N)
  -> N;
rewrite({sum, A, B}) 
  -> rewrite({sum, rewrite(A), rewrite(B)});
rewrite({mul, A, B})
  -> rewrite({mul, rewrite(A), rewrite(B)}).

35> c(rewrite).                             
{ok,rewrite}
36> rewrite:rewrite({mul, 4, {sum, -2, 2}}).
0
37> rewrite:rewrite({mul, 4, {sum, 1, 2}}). 
12
38> rewrite:rewrite({mul, {sum, 1, 2}, 4}). 
12

public Term simplify(Term term) {
  _Term x = new _Term();
  if (term.matches(new Mul(new Num(0), x)))
    return new Num(0);
  if (term.matches(new Mul(new Num(1), x))
    return x.value;
  _Term f = new _Term();
  if (term.matches(new Add(new Num(0), f))
    return f.value;
  if (term.matches(new Add(f, new Num(0)))
    return f.value;
  return term;
}

public Term simplify(Term term)
{
    if(term instanceof Mul)
    {
        Mul term2 = (Mul) term;
        Term term3 = term2.l();
        Term term4 = term2.r();
        if (term3 instanceof Num)
        {
            switch(((Num)term3).n())
            {
            case 0:
                return new Num(0);
            case 1:
                return term4;
            default:
                return term;
            }
        }
    }
    else if (term instanceof Add)
    {
        Add term2 = (Add) term;
        Term term3 = term2.l();
        Term term4 = term2.r();
        if (term3 instanceof Num && ((Num)term3).n() == 0)
            return term4;
        else if (term4 instanceof Num && ((Num)term4).n() == 0)
            return term3;
    }
    return term;
}

mylist.map(x => match x { ... })

T1 = insert(K, T0)

[H | T] = get_list()
{A1, A2} = get_tuple()

  override def flatMap[B](f: A => Iterable[B]): Stream[B] =
    if (isEmpty) Stream.empty
    else
    {
      val s: Stream[B] = f(head) match
      {
        case x: Stream[_] => x
        case y: List[_]   => y.toStream
        case z            => z.toList.toStream
      }
      s append (tail flatMap f)
    }

@PatternMatching
Term simplify(Term term, MyPattern p) {
    if (!p.matches("hola"))
    {
        if (term.matches(new Num(1))) 
        ...
    }
}

Term simplify(Term term, MyPattern p) {
    if (!p.matches("hola"))
        return trueSimplify(term);
}

@PatternMatching
Term trueSimplify(Term term)
        if (term.matches(new Num(1))) 
        ...

interface Term
{
    interface Num extends Term { int n(); }
    interface Mul extends Term { Term l(); Term r(); }
    interface Add extends Term { Term l(); Term r(); }
}
// реализации
class NumClass implements Term.Num
{
    int n;
    public NumClass(int n) { this.n = n; }
    public int n() { return n; }
}
class MulClass implements Term.Mul
{
    Term l, r;
    public MulClass(Term l, Term r) { this.l = l; this.r = r; }
    public int l() { return l; }
    public int r() { return r; }
}
class AddClass implements Term.Num
{
    Term l, r;
    public AddClass(Term l, Term r) { this.l = l; this.r = r; }
    public int l() { return l; }
    public int r() { return r; }
}

// у него методы объявлены final чтобы случайно не перекрыли
class PatternMatcher
{
    // общий выковыриватель типов объектов
    public final Object matches(Object[] a)
    {
        Class c[] = new Class[a.length];
        for (int k = 0; k < a.length; k++)
            c[k] = a[k].getClass();
        return matches(a, c);
    }
    // вызывальщик методов, которые матчат
  public final Object matches(Objec[] a, Class[] c)
  {
        try { this.getClass().getMethod("matches", c).invoke(this, a); }
        catch(Exception e) {throw new MatchingException(); }
  }
}

class Simplifier extends PatternMatcher
{
    public Term matches(Mul m)
    {
        if (m.l().equals(new Num(0))
            return new Num(0);
        else if (m.l().equals(new Num(1))
            return m.r();
        else
            return m;
    }
    
    public Term matches(Add a)
    {
        if (a.l().equals(new Num(0))
            return a.r();
        else if (a.r().equals(new Num(0))
            return a.l();
        else
            return a;
    }
    
    // вот этот метод должен пользователь
    // вызывать явно в своём коде
    public Term matches(Term t)
    {
        return matches(new Object[]{t}); // вызывается метод в классе PatternMatcher
    }
}

abstract class Term {    public void accept(TermVisitor v); }

class Num extends Term
{
    int n;
    public Num(int n) { this.n = n; }
    public void accept(TermVisitor v) { v.visit(this); }
}
class Mul extends Term
{ 
    Term l, r;
    public Mul(Term l, Term r) { this.l = l; this.r = r; }
    public void accept(TermVisitor v) { v.visit(this); }}
}
class Add extends Term
{ 
    Term l, r;
    public Add(Term l, Term r) { this.l = l; this.r = r; }
    public void accept(TermVisitor v) { v.visit(this); }}
}

interface TermVisitor
{
    public void visit(Num n);
    public void visit(Mul m);
    public void visit(Add a);
}

class SimplifyVisitor implements TermVisitor
{
    Term t; // возвращаемое значение
    public SimplifyVisitor(Term t) { this.t = t; }

    public void visit(Num n) {}
    public void visit(Mul m)
    {
        if (m.l().equals(new Num(0))
            t = new Num(0);
        else if (m.l().equals(new Num(1))
            t = m.r();
    }
    public void visit(Add a)
    {
        if (a.l().equals(new Num(0))
            t = a.r();
        else if (a.r().equals(new Num(0))
            t = a.l();
    }
}

    private def mkTree[B](isBlack: Boolean, k: A, v: B, l: Tree[B], r: Tree[B]) = 
      if (isBlack) BlackTree(k, v, l, r) else RedTree(k, v, l, r)

    def upd[B1 >: B](k: A, v: B1): Tree[B1] = 
    {
      def balanceLeft(isBlack: Boolean, z: A, zv: B, l: Tree[B1], d: Tree[B1]) = l match
      {
        case RedTree(y, yv, RedTree(x, xv, a, b), c) => 
          RedTree(y, yv, BlackTree(x, xv, a, b), BlackTree(z, zv, c, d))
        case RedTree(x, xv, a, RedTree(y, yv, b, c)) =>
          RedTree(y, yv, BlackTree(x, xv, a, b), BlackTree(z, zv, c, d))
        case _ =>
          mkTree(isBlack, z, zv, l, d)
      }
      def balanceRight(isBlack: Boolean, x: A, xv: B, a: Tree[B1], r: Tree[B1]) = r match
      {
        case RedTree(z, zv, RedTree(y, yv, b, c), d) => 
          RedTree(y, yv, BlackTree(x, xv, a, b), BlackTree(z, zv, c, d))
        case RedTree(y, yv, b, RedTree(z, zv, c, d)) =>
          RedTree(y, yv, BlackTree(x, xv, a, b), BlackTree(z, zv, c, d))
        case _ =>
          mkTree(isBlack, x, xv, a, r)
      }
      if (k < key)
              balanceLeft(isBlack, key, value, left.upd(k, v), right)
      else if (key < k)
        balanceRight(isBlack, key, value, left, right.upd(k, v))
      else
              mkTree(isBlack, k, v, left, right)
    }

private <A, B> Tree<B> mkTree(Boolean isBlack, A k, B v, Tree<B> l, Tree<B> r)
{
    if (isBlack) 
        return new BlackTree<B>(k, v, l, r);
    else 
        return new RedTree<B>(k, v, l, r);
}

@PatternMatching
private <A, B, B1> Tree<B> balanceLeft(Boolean isBlack, A z, B zv, Tree<B1> l, Tree<B1> d)
{
    _Boolean x = new _Boolean();
    _Boolean y = new _Boolean();
    _A yv = new _A();
    _A xv = new _A();
    _Tree<B1> a = new _Tree<B1>();
    _Tree<B1> b = new _Tree<B1>();
    _Tree<B1> c = new _Tree<B1>();
    if (l.matches(new RedTree<B>(y, yv, new RedTree<B>(x, xv, a, b), c))) 
        return new RedTree<B>(y.value, yv.value, 
            new BlackTree<B>(x.value, xv.value, a.value, b.value), 
            new BlackTree<B>(z.value, zv.value, c.value, d.value));
    else if (l.matches(RedTree<B>(x, xv, a, new RedTree<B>(y, yv, b, c)))) 
        return new RedTree<B>(y.value, yv.value, 
            new BlackTree<B>(x.value, xv.value, a.value, b.value), 
            new BlackTree<B>(z.value, zv.value, c.value, d.value));
    else
        return mkTree(isBlack, z, zv, l, d);
}

@PatternMatching
private <A, B, B1> Tree<B> balanceRight(Boolean isBlack, A x, B xv, Tree<B1> a, Tree<B1> r)
{
    _Boolean z = new _Boolean();
    _Boolean y = new _Boolean();
    _A zv = new _A();
    _A yv = new _A();
    _Tree<B1> b = new _Tree<B1>();
    _Tree<B1> c = new _Tree<B1>();
    _Tree<B1> d = new _Tree<B1>();
    if (r.matches(new RedTree<B>(z, zv, new RedTree<B>(y, yv, b, c), d))) 
        return new RedTree<B>(y.value, yv.value, 
            new BlackTree<B>(x.value, xv.value, a.value, b.value), 
            new BlackTree<B>(z.value, zv.value, c.value, d.value));
    else if (r.matches(RedTree<B>(y, yv, b, new RedTree<B>(z, zv, c, d)))) 
        return new RedTree<B>(y.value, yv.value, 
            new BlackTree<B>(x.value, xv.value, a.value, b.value), 
            new BlackTree<B>(z.value, zv.value, c.value, d.value));
    else
        return mkTree(isBlack, x, xv, a, r);
}
      
public <A, B> Tree<B> upd(A k, B v)
{
    if (k < key)
        balanceLeft(isBlack, key, value, left.upd(k, v), right);
    else if (key < k)
        balanceRight(isBlack, key, value, left, right.upd(k, v));
    else
        mkTree(isBlack, k, v, left, right);
}

  private def matches(gs1: List[UGP], gs2: List[UGP]): Option[(() => Unit, () => Any, () => Any)] =
    (gs1, gs2) match {
      case (Nil, _) => None
      case (_, Nil) => None
      case (UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2) =>
        if (a1 == a2 && d1 == !d2)
          Some(((() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1))))
        else matches(gs1, rest2) match {
          case None => matches(rest1, gs2)
          case Some(t) => Some(t)
        }
    }

// Scala

def runFilters(in_val: FieldType, filter: List[FieldType => FieldType]): FieldType =
     filter match {
       case Nil => in_value
       case x :: xs => runFilters(x(in_val), xs)
     }
     
// Java

FieldType runFilters(FiledType in_val, Functor filter[])
{
        for(filter in filters)
        {
            if(filter != NULL)
                in_val = filter(in);
        }
        return in_val;
}

// Scala

def runFilters(in_val: FieldType, filter: List[FieldType => FieldType]): FieldType =
     filter match {
       case Nil => in_val
       case x:MyFilter.type :: xs => runFilters(x(in_val), xs)
       // мы еще не реализовали другие фильтры
       case _ :: xs => runFilters(in_val, xs)
     }
     
// Java

FieldType runFilters(FiledType in_val, Functor filter[])
{
    for(filter in filters)
    {
            if(filter != NULL && filter instanceof MyFilter)
                filter(in_val);
    }
}

// Scala
// Реализованы только фильтры MyFilter и ComplexFlter
// Для ComplexFilter необходимо елаь препроцессинг

def runFilters(in_val: FieldType, filter: List[FieldType => FieldType]): FieldType =
     filter match {
       case Nil => in_val

       case x:MyFilter.type :: xs => runFilters(x(in_val), xs)

       case x:ComplexFilter.type :: xs =>
           in_val = Preprocess(in_val);
           runFilters(in_val, xs)

       case _ :: xs => runFilters(in_val, xs)
     }
     
// Java
// Реализованы только фильтры MyFilter и ComplexFlter
// Для ComplexFilter необходимо елаь препроцессинг

FieldType runFilters(FiledType in_val, Functor filter[])
{
    for(filter in filters)
    {
            if(filter != NULL)
            {
                if(filter instanceof MyFilter)
                {
                    in_val = filter(in_val);
                }
                else if(filter instanceof ComplexFilter)
                {
                    in_val = Preprocess(in_val);
                    in_val = filter(in_val);
                }
            }
    }
    
    return in_val;
}

Если взрослого мыша взять и, бережно держа,
Натыкать в него иголок, вы получите ежа.
Если этого ежа, нос заткнув, чтоб не дышал,
Кинуть в речку, где поглубже, вы получите ерша.
Если этого ерша, головой в тиски зажав,
Посильней тянуть за хвост, вы получите ужа.
Если этого ужа, приготовив два ножа...
Впрочем, он, наверно, сдохнет.
Но идея хороша!