Z>// SCALA!
Z>class Term
Z>case class Num(n: int)           extends Term
Z>case class Var(name: String)     extends Term
Z>case class Mul(l: Term, r: Term) extends Term
Z>case class Add(l: Term, r: Term) extends Term

Z>// Now let's say we want to implement some simplification rules on such terms.
Z>// Two useful simplifications apply the equalities:
Z>// 0 * x  =  0
Z>// 1 * x  =  x

Z>def simplify(term: Term) = term match {
Z>  case Mul(Num(0), x) => Num(0)
Z>  case Mul(Num(1), x) => x
Z>  case _ => term
Z>}
Z>

Z>Ему ответили, что мултиплай — диспатч на яве — это просто

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

Z>class Term
Z>case class Num(n: int)           extends Term
Z>case class Var(name: String)     extends Term
Z>case class Mul(l: Term, r: Term) extends Term
Z>case class Add(l: Term, r: Term) extends Term

Z>def simplify(term: Term) = term match {
Z>  case Mul(Num(0), x) => Num(0)
Z>  case Mul(Num(1), x) => x
Z>  case _ => term
Z>}

Z>>Ему ответили, что мултиплай — диспатч на яве — это просто

SR>    public Term simplify(Term term) {
SR>        _Term x = new _Term();
SR>        if (term.equals(new Mul(new Num(0), x))) return new Num(0);
SR>        if (term.equals(new Mul(new Num(1), x))) return x.value;
SR>        return term;
SR>    }

public Term simplify(Term term)
{
    Term term1 = term;
    Term term4;
    if(term1 instanceof Mul)
    {
        Mul mul = (Mul)term1;
        Term term2 = mul.l();
        Term term3 = mul.r();
        if(term2 instanceof Num)
        {
            switch(((Num)term2).n())
            {
            default:
                break;

            case 0: // '\0'
                term4 = new Num(0);
                break;

            case 1: // '\001'
                term4 = term3;
                break;
            }
        }
    }
    term4 = term;
    return term4;
}

def simplify(term: Term) = term match {
  case Mul(Num(0), x) => Num(0)
  case Mul(Num(1), x) => x
  case Add(Num(0), f) => f
  case Add(f, Num(0)) => f
  case _ => term
}

    public Term simplify(Term term)
    {
        Term term1 = term;
        if(!(term1 instanceof Mul)) goto _L2; else goto _L1
_L1:
        Term term2;
        Term term3;
        Mul mul = (Mul)term1;
        term2 = mul.l();
        term3 = mul.r();
        if(!(term2 instanceof Num)) goto _L4; else goto _L3
_L3:
        ((Num)term2).n();
        Term term6;
        JVM INSTR tableswitch 0 1: default 192
    //                   0 64
    //                   1 75;
           goto _L4 _L5 _L6
_L5:
        term6 = new Num(0);
          goto _L7
_L6:
        term6 = term3;
          goto _L7
_L2:
        if(!(term1 instanceof Add)) goto _L4; else goto _L8
_L8:
        Term term4;
        Term term5;
        Add add = (Add)term1;
        term4 = add.l();
        term5 = add.r();
        if(!(term4 instanceof Num)) goto _L10; else goto _L9
_L9:
        Num num = (Num)term4;
        if(num.n() != 0) goto _L12; else goto _L11
_L11:
        term5;
          goto _L13
_L12:
        if(!(term5 instanceof Num) || ((Num)term5).n() != 0) goto _L4; else goto _L14
_L14:
        Term f = num;
          goto _L15
_L10:
        if(!(term5 instanceof Num) || ((Num)term5).n() != 0) goto _L4; else goto _L16
_L16:
        f = term4;
_L15:
        f;
          goto _L13
_L4:
        term6 = term;
_L7:
        term6;
_L13:
        return;
    }

require'zstd'
local ppp = zstd.ppp

-- Scala:
-- def simplify(term: Term) = term match {
--   case Mul(Num(0), x) => Num(0)
--   case Mul(Num(1), x) => x
--   case Add(Num(0), f) => f
--   case Add(f, Num(0)) => f
--   case _ => term
-- }

local fun simplify
  | {"Mul",{"Num",0},x} -> return {"Num",0}
  | {"Mul",{"Num",1},x} -> return simplify(x)
  | {"Add",{"Num",0},f} -> return simplify(f)
  | {"Add",f,{"Num",0}} -> return simplify(f)
  | term -> return term
end

-- TEST:
ppp(1, simplify({"Mul",{"Num",1},"X"}))                    --> "X"
ppp(2, simplify({"Mul",{"Num",0},"X"}))                    --> {"Num",0}
ppp(3, simplify({"Add",{"Num",0},"F"}))                    --> "F"
ppp(4, simplify({"Add","F",{"Num",0}}))                    --> "F"
ppp(5, simplify({"Mul",{"Num",1}, {"Add",{"Num",0},"F"}})) --> "F"

local function simplify(_u0)
    if type(_u0) == 'table' then
        if #_u0 == 3 then
            if _u0[1] == "Mul" then
                if type(_u0[2]) == 'table' then
                    if #_u0[2] == 2 then
                        if _u0[2][1] == "Num" then
                            if _u0[2][2] == 0 then return {"Num";0}
                            else
                                if _u0[2][2] == 1 then return simplify(_u0[3])
                                else return _u0
                                end;
                            end;
                        else return _u0
                        end;
                    else return _u0
                    end;
                else return _u0
                end;
            else
                if _u0[1] == "Add" then
                    if type(_u0[2]) == 'table' then
                        if #_u0[2] == 2 then
                            if _u0[2][1] == "Num" then
                                if _u0[2][2] == 0 then return simplify(_u0[3])
                                else
                                    if type(_u0[3]) == 'table' then
                                        if #_u0[3] == 2 then
                                            if _u0[3][1] == "Num" then
                                                if _u0[3][2] == 0 then
                                                    return simplify(_u0[2])
                                                else return _u0
                                                end;
                                            else return _u0
                                            end;
                                        else return _u0
                                        end;
                                    else return _u0
                                    end;
                                end;
                            else
                                if type(_u0[3]) == 'table' then
                                    if #_u0[3] == 2 then
                                        if _u0[3][1] == "Num" then
                                            if _u0[3][2] == 0 then
                                                return simplify(_u0[2])
                                            else return _u0
                                            end;
                                        else return _u0
                                        end;
                                    else return _u0
                                    end;
                                else return _u0
                                end;
                            end;
                        else
                            if type(_u0[3]) == 'table' then
                                if #_u0[3] == 2 then
                                    if _u0[3][1] == "Num" then
                                        if _u0[3][2] == 0 then
                                            return simplify(_u0[2])
                                        else return _u0
                                        end;
                                    else return _u0
                                    end;
                                else return _u0
                                end;
                            else return _u0
                            end;
                        end;
                    else
                        if type(_u0[3]) == 'table' then
                            if #_u0[3] == 2 then
                                if _u0[3][1] == "Num" then
                                    if _u0[3][2] == 0 then
                                        return simplify(_u0[2])
                                    else return _u0
                                    end;
                                else return _u0
                                end;
                            else return _u0
                            end;
                        else return _u0
                        end;
                    end;
                else return _u0
                end;
            end;
        else return _u0
        end;
    else return _u0
    end;
end;

boolean is(int number) {
  if (number > 0)
    return true;
  if (number <= 0)
    return false;
  // отсутствует ошибка, что "This method must return a result of type boolean."
}

LCR>public Term simplify(Term term)
LCR>{
LCR>    Term term1 = term;
LCR>    Term term4;
LCR>    if(term1 instanceof Mul)
LCR>    {
LCR>       ...
LCR>    }
LCR>    term4 = term;
LCR>    return term4;
LCR>}
LCR>

LCR>def simplify(term: Term) = term match {
LCR>  case Mul(Num(0), x) => Num(0)
LCR>  case Mul(Num(1), x) => x
LCR>  case Add(Num(0), f) => f
LCR>  case Add(f, Num(0)) => f
LCR>  case _ => term
LCR>}
LCR>

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

SR>boolean is(int number) {
SR>  if (number > 0)
SR>    return true;
SR>  if (number <= 0)
SR>    return false;
SR>  // отсутствует ошибка, что "This method must return a result of type boolean."
SR>}
SR>

    if (((int) Math.pow(number, 19)) - number) % 19 == 0)
        return true;

sealed abstract class Term
case class Num(n: int)           extends Term
case class Var(name: String)     extends Term
case class Mul(l: Term, r: Term) extends Term
case class Add(l: Term, r: Term) extends Term

class App extends Application
{
    def simplify(term: Term) = term match {
      case Mul(Num(0), x) => Num(0)
      case Mul(Num(1), x) => x
      case Add(Num(0), f) => f
      case Add(f, Num(0)) => f
//      case _ => term
    }
}

test2.scala:16: warning: match is not exhaustive!
missing combination            Num
missing combination            Var
        def simplify(term: Term) = term match {
                                   ^
one warning found

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

    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;
    }

LCR>Круто!

LCR>То есть, как я понял, ты какое-то время писал на голом Луа, потом тебя это достало, и ты решил создать метаязык для Луа, так? Паттерн-матчинг значит там уже есть, а ещё что? ФВП, list comprehensions, continuations?

-- Сердце Вадлеровского претти-принтера украденное одновременно у Линдига(Quest)
-- и у Daan Leijen (Haskell PPrint)

  -- best : (sb,int,int,Cells) -> sb
  -- @sb - string buffer
  -- @n  - indentation of current line
  -- @k  - current column
  -- Cells : listof {indent, Mode, Doc}  
  local function best(sb, n, k, cells) case cells of
      | []                -> return sb
      | {i,_,Empty}  :: z -> return best(sb,n,k,z)
      | {i,m,{'Cons',x,y}}  :: z -> return best(sb,n,k,{i,m,x}::{i,m,y}::z)
      | {i,m,{'Nest',j,x}}  :: z -> return best(sb,n,k,{i+j,m,x}::z)
      | {i,_,{'Text',s}}    :: z -> return best(emit(sb,s),n,k+#s,z)
      | {i,FLT,{'Break',s}} :: z -> return best(emit(sb,s),n,k+#s,z)
      | {i,BRK,{'Break',_}} :: z -> return best(nl(sb,i),i,i,z)
      | {i,FLT,{'Group',x}} :: z -> return best(sb,w,k,{i,FLT,x}::z)
      | {i,BRK,{'Group',x}} :: z -> 
          local ribbonleft = (w - k) `min` (ribbon - k + n)
          if fits(ribbonleft,k,{i,FLT,x}::z) then
            return best(sb,n,k,{i,FLT,x}::z)
          else
            return best(sb,n,k,{i,BRK,x}::z)
          end
      | {i,m,{'Column',f}}  :: z -> return best(sb,n,k,{i,m,f(k)}::z)
      | {i,m,{'Nesting',f}} :: z -> return best(sb,n,k,{i,m,f(i)}::z)
      | x -> error(tostring(x))
    end
  end
  -- return of layout
  return best(sb,0,0,{0,BRK,doc}::[])

-- prefix                        
(?)  = assert                   ---> _prefix_question = assert;
?getImage("some.img")           ---> _prefix_question(getImage"some.img");

-- right assoc
(:-:) = docCons                 ---> _op_colon_dash_colon = docCons;
mydoc = adoc :-: bdoc :-: empty ---> mydoc = _op_colon_dash_colon(adoc
                                --->                             ,_op_colon_dash_colon(bdoc,empty));
-- infixl 5 pseudo-operator
x = (fn(x)=> x+42) `map` xs     ---> x = map((function(x) return x+42 end),xs);

-- Scala's thunk
print(=> 1/0)                   ---> print(function() return 1/0 end);

Проверить, существует ли такое поле

{field_name}

Сравнить поле field_name с полем field2_name (также можно использовать '=', '/=', '<', '=<', '>', '>=' )

{field_name, {'=', field2_name}}

Сравнить значение поля с любым другим значением:

{field_name, {'=', Value}}

Использовать callback-функцию. Функция может быть лямбдой или любой функцией из любого модуля в виде module:function/2 или {module, function}

{field_name, F}

Использовать callback-функцию с дополнительным значением. Функция может быть лямбдой или любой функцией из любого модуля в виде module:function/3 или {module, function}

{field_name, {F, Value}}

%%{field}
validate_rule({FieldName}) ->
    ok.

%%{field, Func}
validate_rule({FieldName, Func}) when is_function(Func) ->
    ok.

%%{field, {'=', field2}}
validate_rule({FieldName, {Operator, FieldName2}}) ->
    ok.

    boolean validate(String login, String password, String password_repeat, String email) {
        return 
          ((login.length() >= 4 && login.length() <= 16)) &&
          ((password.length() >= 4 && password.length() <= 16)) &&
          ((password.equals(password_repeat))) &&
          ((email.matches("\\w+@\\w+\\.\\w+")));        
    }

SR>    boolean validate(String login, String password, String password_repeat, String email) {
SR>        return 
SR>          ((login.length() >= 4 && login.length() <= 16)) &&
SR>          ((password.length() >= 4 && password.length() <= 16)) &&
SR>          ((password.equals(password_repeat))) &&
SR>          ((email.matches("\\w+@\\w+\\.\\w+")));        
SR>    }
SR>

process_signup(A) ->
    ValidateLength = fun(A, Field) ->
        %% проверяем на длину
    end,
    EmailCheck = fun(Args, Field2) ->
        %% проверяем правильность мыла
    end,

    buktu_form:validate(A, [
        {login, F},              %% проверяем с использованием внешней функции
        {email, EmailCheck},     %% проверяем с использованием внешней функции
        {password, [{'=', password_repeat}, F]} %% проверяем на равенство с другим полем
                                                %% а потом - с использованием внешней функции
    ]).

[{login,invalid_field},
 {email,invalid_field},
 {password,[{invalid_fields,[password,password_repeat]},
            invalid_field]}]

[{login,length},
 {email,invalid_value},
 {password,[{not_equal,password_repeat},
            length]}]

validate([
    {registration},
    {checkbox1},
    {checkbox2},
    {year, {'<', 1980}}
    {login, F},              %% внешние функции остаются те же
    {email, EmailCheck},     
    {password, [{'=', password_repeat}, F]} 
])

%% {field, {Rule, and, Rule2}}
%% оба правила должны сработать

validate(FieldName, {Rule1, and, Rule2}) ->
        %% разбиваем на валидацию двух правил
    validate({FieldName, Rule}) == {} andalso validate({FieldName, Rule2}) == {}

%% {field, {Rule, or, Rule2}}
%% одно из правил должно сработать

validate(FieldName, {Rule1, or, Rule2}) ->
        %% разбиваем на валидацию двух правил
    validate({FieldName, Rule}) == {} orelse validate({FieldName, Rule2}) == {}

abstract class Term {};
class Num extends Term {};
class Var extends Term {}

@Exhaustive
Term simplify(Term term) {
  if (term instanceof Num)
     return ...;
  if (term instanceof Var)
     return ...;
  // отсутствует "This method must return a result of type Term."
}

if (object.equals(new Object(...))

LCR>будут прогоняться через препроцессор, а последний будет выплёвывать уже явовский код, который потом будет компилироваться с помощью javac. Плохо.

M>Причем полученый список ошибок разбрать не просто легко, а очнь легко ПМ по [H|T] по списку и вперед

    public void main() {
        Form form = new Form();
        form.put("login", "name");
        form.put("password", "123");
        form.put("password_repeated", "123");
        form.put("email", "name@domain.com");
        form.put("born_year", "1980");
        
        Object[] rules = new Object[] {
            "login", "length", parameters(4, 16),
            "password", "length", parameters(4, 16),
            "password", "=", parameters("password_repeated"),
            "email", "email", parameters(),
            "born_year", "<", parameters("1990")
        };
        
        check(form, rules);
    }

    // О боже мой, кажется, я реализовал сопоставление с образцом для списка в Java!
    // Этого не может быть, наверное я сплю.
    private void check(Form form, Object[] rules) {
        for (int index = 0; index < rules.length; index += 3) {
            String field = rules[index].toString();
            String rule = rules[index+1].toString();
            Object[] parameters = (Object[])rules[index+2];
        
            check(form, field, rule, parameters);
        }
    }

    private void check(Form form, String field, String rule, Object[] parameters) {
        if (rule.equals("length")) { 
            int min = (Integer)parameters[0]; 
            int max = (Integer)parameters[1];
            checkLength(form.get(field), min, max);
        }
        ...
        // остальной код в той же мере тривиален
    }

{ok, {{Version, 200, ReasonPhrase}, Headers, Body}} =
      http:request(...
      
{ok, {_, _, Body}} = http:request(...


{ok, {_, 200, _}, _, _} = http:request(

     | {i,FLT,{'Break',s}} :: z -> return best(emit(sb,s),n,k+#s,z)
     | {i,BRK,{'Break',_}} :: z -> return best(nl(sb,i),i,i,z)
     | {i,FLT,{'Group',x}} :: z -> return best(sb,w,k,{i,FLT,x}::z)

if(term.m == FLT && term.cell.type == 'Break' && term.cell.data == s)
{
}
else if(term.m == BRK && term.cell.type == 'Break')
{
}
else if(term.m == FLT && term.cell.type == 'Group' && term.cell.data == x)
{
}

M>>А ПМ позвлит все задачи решить декларативно. Это не магическая пуля, конечно, писать все равно придется Но каждый раз это будет легко и — главное! — одинаково.

rules_list         = [fields_and_rules]
fields_and_rules   = [field_rules]
field_rules        = {field} | {field, Rules}
Rules              = Rule | [Rule]
Rule               = function | OperatorRule | FunctionRule
OperatorRule       = {Operator, value} | (Operator, field)
Operator           = '=' | '/=' | '<' | '=<' | '>' | '>='
FunctionRule       = {function, value} | {function, field}

SR>abstract class Term {};
SR>class Num extends Term {};
SR>class Var extends Term {}

SR>@Exhaustive
SR>Term simplify(Term term) {
SR>  if (term instanceof Num)
SR>     return ...;
SR>  if (term instanceof Var)
SR>     return ...;
SR>  // отсутствует "This method must return a result of type Term."
SR>}
SR>

      _Term x = new _Term();
      if (term.equals(new Mul(new Num(1), x))) return x.value;

...
case class Yo(n: Add) extends Term

def simplify(term: Term) = term match {
  ...
  case Yo(x) => x
  case _ => term
}

M>>>При этом с ПМ рекрсия по списку тривиальна

M>>>{ok, {{Version, 200, ReasonPhrase}, Headers, Body}} =
M>>>      http:request(...
      
M>>>{ok, {_, _, Body}} = http:request(...


M>>>{ok, {_, 200, _}, _, _} = http:request(
M>>>

M>Ну, мы ж про паттерн-матчинг говорим? А тут вполне себе паттерн-матчинг. Вполне понятный даже незнакомому с Эрлангом

    private Response getResponse() {
        return new Response(list (
            list ( "HTTP/1.1", 200, "OK" ),
            list (
                "Content-Type: text/html; charset=UTF-8", 
                "Content-Length: 0" ),
            list ( "" )
        ));        
    }
    
    public void parse() {
        Response response = getResponse();
        
        Any _ = new Any();
        Match version = new Match(), responsePhrase = new Match(), headers = new Match(), body = new Match();        
        if (response.matches( list ( list (version, 200, responsePhrase), headers, body ))) {
            System.out.println(responsePhrase.value);
        }
        if (response.matches( list (_, _, body))) {
            System.out.println(body.value);
        }        
        if (response.matches( list ( list (_, 200, _), headers, body))) {
            System.out.println(headers.value);
        }
    }

M>Ну, в исходном

Автор: z00n
Дата: 14.12.07

сообщении был приведен и пример кода их компилятора

M>А ПМ в итоге позволяет читать код, как книгу, без необходимости пробираться сквозь дебри if-ов и попыток понять, что же автор хотел сказать тем или иным циклом

M>Или в нечто ему подобное. Потому что мы же хотим некую общую функцию, которая поможет разбирать образцы не только на одном примере разбора веб-форм

M>Ну, для калькулятора был код с term.equals, для проверки веб-=форм был код с if'ами. Для этого конкретного примера term.equals не подойдет, потому что нам не всегда все значения нужны. Так что if-ы

class A {
  public Class1 field1;
  public Class2 field2;

  public boolean equals(Object object) {
    return object instanceof A && equals((A)object);
  }
  
  private boolean equals(A a) {
     return field1.equals(a.field1) && field2.equals(a.field2);
  }
}

LCR>      _Term x = new _Term();
LCR>      if (term.equals(new Mul(new Num(1), x))) return x.value;
LCR>

public class _Term extends Term {
  public Term value;
}

M>>>>При этом с ПМ рекрсия по списку тривиальна

match([]) ->
    not_ok.
match([H|T]) ->
    ok.

match([{ok, Value}|T]) ->
    ok.
match([что_то_там|T]) ->
    ok.
match([{ok, {{Version, 200, ReasonPhrase}, Headers, Body}}|T]) ->
    %% здесь мы сразу получаем доступ ко всем переменным
    ok.

M>>>>{ok, {{Version, 200, ReasonPhrase}, Headers, Body}} =
M>>>>      http:request(...
      
M>>>>{ok, {_, _, Body}} = http:request(...


M>>>>{ok, {_, 200, _}, _, _} = http:request(
M>>>>

M>>Ну, мы ж про паттерн-матчинг говорим? А тут вполне себе паттерн-матчинг. Вполне понятный даже незнакомому с Эрлангом

SR>    private Response getResponse() {
SR>        return new Response(list (
SR>            list ( "HTTP/1.1", 200, "OK" ),
SR>            list (
SR>                "Content-Type: text/html; charset=UTF-8", 
SR>                "Content-Length: 0" ),
SR>            list ( "" )
SR>        ));        
SR>    }
    
SR>    public void parse() {
SR>        Response response = getResponse();
        
SR>        Any _ = new Any();
SR>        Match version = new Match(), responsePhrase = new Match(), headers = new Match(), body = new Match();        
SR>        if (response.matches( list ( list (version, 200, responsePhrase), headers, body ))) {
SR>            System.out.println(responsePhrase.value);
SR>        }
SR>        if (response.matches( list (_, _, body))) {
SR>            System.out.println(body.value);
SR>        }        
SR>        if (response.matches( list ( list (_, 200, _), headers, body))) {
SR>            System.out.println(headers.value);
SR>        }
SR>    }
SR>

%% Первый пример, http://rsdn.ru/Forum/Message.aspx?mid=2766871&only=1
%% намеренно сокращен :)

match({0, x}) ->
    0;
match({1, x}) ->
    x;
match({a, b}) ->
    a*b;
    
%% Второй пример, с правилами валидации
%% http://rsdn.ru/Forum/Message.aspx?mid=2927907&only=1
%% Слегка сокращен

match({Field, Rule}) ->
    match_rule(Field, Rule);
match(Field) when is_atom(Field) ->
    field_exists(Field);
    
match_rule(Field, {Func, Value}) ->
  Func(Field, Value);
  
%% третий пример, http://rsdn.ru/Forum/Message.aspx?mid=2927730&only=1

match([]) ->
    ok;
match({i, _, empty}) ->
    ok;
match({i, m, {'Cons', x, y}}) ->
    ok;
    %% и так далее


%% четвертый пример, http://rsdn.ru/Forum/Message.aspx?mid=2929226&only=1

match({ok, {{Version, 200, ReasonPhrase}, Headers, Body}}) ->
    ok;
match({ok, {{_, 404, ReasonPhrase}, _, _}}) ->
    ok;

M>>Или в нечто ему подобное. Потому что мы же хотим некую общую функцию, которая поможет разбирать образцы не только на одном примере разбора веб-форм

M>>Ну, для калькулятора был код с term.equals, для проверки веб-=форм был код с if'ами. Для этого конкретного примера term.equals не подойдет, потому что нам не всегда все значения нужны. Так что if-ы

M>>>>>При этом с ПМ рекрсия по списку тривиальна

M>match([]) ->
M>    not_ok.
M>match([H|T]) ->
M>    ok.
M>

boolean matches(Object[] list, Object[] pattern) {
}

M>match({0, x}) ->
M>    0;
M>match({1, x}) ->
M>    x;
M>match({a, b}) ->
M>    a*b;
M>

Match x = new Match();
if (list.matches(0, x))
  return 0;
if (list.matches(1, x))
  return x.value;
Match a = new Match, b = new Match();
if (list.matches(a, b))
  return a.value * b.value;

M>match({Field, Rule}) ->
M>    match_rule(Field, Rule);
M>match(Field) when is_atom(Field) ->
M>    field_exists(Field)
M>match_rule(Field, {Func, Value}) ->
M>  Func(Field, Value);
M>

Match field = new Match(), rule = new Match();
if (list.matches(field, rule)) {
  Match func = new Match(), value = new Match();
  if (rule.value.matches(func, value))
    return func.value(field.value, value.value);
}
if (list.matches(field))
  return fieldExists(field.value);

M>match([]) ->
M>    ok;
M>match({i, _, empty}) ->
M>    ok;
M>match({i, m, {'Cons', x, y}}) ->
M>    ok;
M>

if (list.matches())
  return ok;
Match i = new Match(), empty = new Match();
if (list.matches(i, _, empty))
  return ok;
Match m = new Match(), x = new Match(), y = new Match();
if (list.matches(i, m, list("Cons", x, y)))
  return ok;

M>match({ok, {{Version, 200, ReasonPhrase}, Headers, Body}}) ->
M>    ok;
M>match({ok, {{_, 404, ReasonPhrase}, _, _}}) ->
M>    ok;
M>

Match ok = new Match(), version = new Match(), reasonPhrase = new Match(), headers = new Match(), body = new Match();
if (list.matches(ok, list (version, 200, reasonPhrase), headers, body)
  return ok;
if (list.matches(ok, list (_, 404, reasonPhrase), _, _)
  return ok;

M>Зачем их тогда упоминать?

variant List[T]
{
| Cons { value : T; tail : List[T]; }
| Null
}

SR>boolean matches(Object[] list, Object[] pattern) {
SR>}
SR>

case input_data of
    [{elem1, elem2}|T] -> сделаем что-то одно
    [[L]|T] -> разбираем вложенный список
    {a, b} -> а ждесь вообще не список, оппаньки
    {[H|T], [H2|T2]} -> и здесь не список передали. но внутри список
    {a, {b, {c, d}}} -> здесь списком даже и не пахнет, но все разобрали
    {_, _, _, _, x} -> нам важен только 5-й параметр, хотя струкутра может быть такой:
    {{a, b, c}, [H|T], {[H2|T2]}, d, e} -> и все равно мы ее сможем разобрать
end

match({1, 2, 3}) ->
    ok;

match({"a", "b", "c"}) ->
    ok;

match([H|T]) ->
    ok.

M>Ничего не понял

M>Так никто про списки изначально и не говорил

M>case input_data of
M>    [{elem1, elem2}|T] -> сделаем что-то одно
M>    [[L]|T] -> разбираем вложенный список
M>    {a, b} -> а ждесь вообще не список, оппаньки
M>    {[H|T], [H2|T2]} -> и здесь не список передали. но внутри список
M>    {a, {b, {c, d}}} -> здесь списком даже и не пахнет, но все разобрали
M>    {_, _, _, _, x} -> нам важен только 5-й параметр, хотя струкутра может быть такой:
M>    {{a, b, c}, [H|T], {[H2|T2]}, d, e} -> и все равно мы ее сможем разобрать
M>end
M>

if (data.matches(list(elem1, elem2), T))
if (data.matches(list(L), T))
if (data.matches(a, b)
if (data.matches(list(H, T), list(H2, T2))
if (data.matches(a, list(b, list(c, d)))
if (data.matches(_, _, _, _, x))
if (data.matches(list(a, b, c), list(H, T), list(list(H2, T2), d, e)))

M>match({1, 2, 3}) ->
M>    ok;

M>match({"a", "b", "c"}) ->
M>    ok;

M>match([H|T]) ->
M>    ok.
M>

if (list.matches(1, 2, 3))
  return ok;

if (list.matches("a", "b", "c")
  return ok;

Match h = new Match(); Tail t = new Tail();
if (list.matches(h, t))
  return ok;

M>>Так никто про списки изначально и не говорил

match({a, b, c})

class Elem {
  a;
  b;
  c;
}

class Term
case class Num(n: int)           extends Term
case class Var(name: String)     extends Term
case class Mul(l: Term, r: Term) extends Term
case class Add(l: Term, r: Term) extends Term

// Now let's say we want to implement some simplification rules on such terms.
// Two useful simplifications apply the equalities:
// 0 * x  =  0
// 1 * x  =  x

def simplify(term: Term) = term match {
  case Mul(Num(0), x) => Num(0)
  case Mul(Num(1), x) => x
  case _ => term
}

class A {
  final Object b;
  Object c;
}

class A {
  final Class1 b;
  Class2 c;

  public A(Class1 b, Class2 c) {
    this.b = b;
    this.c = c;
  }

  public Class1 getB() { 
    return b; 
  }
  public void setC(Class2 c) { 
    this.c = c; 
  }
  public Class2 getC() { 
    return c; 
  }
}

M>>match({a, b, c})
M>>

M>>class Elem {
M>>  a;
M>>  b;
M>>  c;
M>>}
M>>

def simplify(term: Term) = term match {
  case Mul(Num(0), x) => Num(0)
  case Mul(Num(1), x) => x
  case _ => term
}

match(Field)
match({Field, {Func, Value})
match({Field, {'=', Value}})

{ok, {{Version, 200, ReasonPhrase}, Headers, Body}}

M>>case input_data of
M>>    [{elem1, elem2}|T] -> сделаем что-то одно
M>>    [[L]|T] -> разбираем вложенный список
M>>    {a, b} -> а ждесь вообще не список, оппаньки
M>>    {[H|T], [H2|T2]} -> и здесь не список передали. но внутри список
M>>    {a, {b, {c, d}}} -> здесь списком даже и не пахнет, но все разобрали
M>>    {_, _, _, _, x} -> нам важен только 5-й параметр, хотя струкутра может быть такой:
M>>    {{a, b, c}, [H|T], {[H2|T2]}, d, e} -> и все равно мы ее сможем разобрать
M>>end
M>>

SR>if (data.matches(list(elem1, elem2), T))
SR>if (data.matches(list(L), T))
SR>if (data.matches(a, b)
SR>if (data.matches(list(H, T), list(H2, T2))
SR>if (data.matches(a, list(b, list(c, d)))
SR>if (data.matches(_, _, _, _, x))
SR>if (data.matches(list(a, b, c), list(H, T), list(list(H2, T2), d, e)))
SR>

class Elem {
  public int a;
  public double b;
  public string c;
  Elem(int aa, double bb, string cc) {a = aa; b = bb; c = cc;}
}

[{elem1, elem2}|T]

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

M>>>case input_data of
M>>>    [{elem1, elem2}|T] -> сделаем что-то одно
M>>>    [[L]|T] -> разбираем вложенный список
M>>>    {a, b} -> а ждесь вообще не список, оппаньки
M>>>    {[H|T], [H2|T2]} -> и здесь не список передали. но внутри список
M>>>    {a, {b, {c, d}}} -> здесь списком даже и не пахнет, но все разобрали
M>>>    {_, _, _, _, x} -> нам важен только 5-й параметр, хотя струкутра может быть такой:
M>>>    {{a, b, c}, [H|T], {[H2|T2]}, d, e} -> и все равно мы ее сможем разобрать
M>>>end
M>>>

SR>>if (data.matches(list(elem1, elem2), T))
SR>>if (data.matches(list(L), T))
SR>>if (data.matches(a, b)
SR>>if (data.matches(list(H, T), list(H2, T2))
SR>>if (data.matches(a, list(b, list(c, d)))
SR>>if (data.matches(_, _, _, _, x))
SR>>if (data.matches(list(a, b, c), list(H, T), list(list(H2, T2), d, e)))
SR>>

new Object[] {_, 2, x}

abstract class Term {};
final class Num extends Term {};
final class Var extends Term {};

@PatternMatching
Term simplify(Term term) {
  if (term.equals(new Num(1))) {
  }
}

T>Кстати, а куда будем учитывать плагины которые тоже нужно писать и поддерживать?

T>Несколько месяцев назад я примерно с такими же доводами выступал. Правда в качестве псевдокода использовал С++.

M>Пока этого одного вида пока никто так и не увидел

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

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

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

function a
  x = 1 * 2 * 3
  a = x * 2
end function

Mul(Mul(Num(1), Num(2)), Num(x)) -> 2 * x

M>>Пока этого одного вида пока никто так и не увидел

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>

match_list([H|T]) ->
    case T of 
        1 -> что-то делаем
        "text" -> делаем что-то еще
        какая-то_сложная_структура -> делаем что-то третье
        _ -> нас вообще T не интересует, работаем с H

object MatchTest2 extends Application {
  def matchTest(x: Any): Any = x match {
    case 1 => "one"
    case "two" => 2
    case y: Int => "scala.Int"
  }
  println(matchTest("two"))
}

    case z: MyClass => z.MyMethod(); z.field1 = 2;

// The simple type match pattern

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

class Color(val red:Int, val green:Int, val blue:Int)
 
case class Red(r:Int) extends Color(r, 0, 0)
case class Green(g:Int) extends Color(0, g, 0)
case class Blue(b:Int) extends Color(0, 0, b)
 
def printColor(c:Color) = c match {
  // байндинг переменной
  case Red(v) => println("Red: " + v)
  case Green(v) => println("Green: " + v)
  case Blue(v) => println("Blue: " + v)
 
    // проверка на тип и байндинг переменной
  case col:Color => {
    print("R: " + col.red + ", ")
    print("G: " + col.green + ", ")
    println("B: " + col.blue)
  }
 
  case null => println("Invalid color")
}
 
printColor(Red(100))
printColor(Blue(220))
 
printColor(new Color(100, 200, 50))
printColor(null)

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

SR>abstract class Term {};
SR>final class Num extends Term {};
SR>final class Var extends Term {};

SR>@PatternMatching
SR>Term simplify(Term term) {
SR>  if (term.equals(new Num(1))) {
SR>  }
SR>}
SR>

@PatternMatching
void matches(data) {
  switch(data) {
    case list(elem1, elem2), T: {...};
    case list(L), T: {...};
    case a, b: {...};
    case list(H, T), list(H2, T2): {...};
    case a, list(b, list(c, d)): {...};
    case _, _, _, _, x: {...};
    case list(a, b, c), list(H, T), list(list(H2, T2), d, e): {...};
  }
}

T>>Кстати, а куда будем учитывать плагины которые тоже нужно писать и поддерживать?

В морду хочешь?

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)}).