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

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

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

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


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

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

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

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

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


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

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

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

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>

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


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

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

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


M>>>>{ok, {_, 200, _}, _, _} = http:request(
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>

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

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

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>

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

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

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

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

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>

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

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

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