// сопоставляющая функция. Её можно инициализировать, чтобы в случае отстутствия шаблона выкидывалось исключение
// к примеру так: matcher = function() { throw new Error("no applicable pattern found") }
var matcher

matcher = combine(PATTERN1, CALLBACK1(OBJ, .. OPTIONAL_ARGS){...}, matcher)
matcher = combine(PATTERN2, CALLBACK2(OBJ, .. OPTIONAL_ARGS){...}, matcher)
// промежуточные результаты matcher можно так же сохранять и использовать в сопоставлении
matcher = combine(PATTERN3, CALLBACK3(OBJ, .. OPTIONAL_ARGS){...}, matcher)

...

// сопоставление
matcher(OBJ, ... OPTIONAL_ARGS)

    var matcher = function(val, arg) {
        print("matcher fallback: val = " + val + ", arg = " + arg)
    }

    matcher = pm.combine({type: "string"}, function(val, arg) {
        print({expr: "matcher(stringVal, arg)", value: "val = " + val + ", arg = " + arg})
    }, matcher)

    matcher = pm.combine({instanceOf: Function}, function(val, arg) {
        print({expr: "matcher(functionVal, arg)", value: "val = " + val + ", arg = " + arg})
    }, matcher)

    matcher = pm.combine({scheme: {key: "number", value: "any"}}, function(val, arg) {
        print({expr: "matcher({key:number, value:any}, arg)", value: "val = (" + val.key + "," + val.value + "), arg = " + arg})
    }, matcher)

    matcher(5, "one")
    matcher("str", "two")
    matcher(new Function("return 1"), "three")
    matcher({key: 12, value: 34}, "four")
    matcher({key: "some", value: "unk"}, "five")

// namespace
var pm = {}

/**
 * Matcher functions constructors are used in pm.combine method.
 * Each key in this object corresponds to the certain pattern member.
 */
pm._matcherConstructors = {
    instanceOf: function (matcher, instanceTarget) {
        return function (obj) {
            if (obj instanceof instanceTarget) {
                return matcher.apply(this, arguments)
            }
            return false
        }
    },

    type: function (matcher, typeId) {
        return function (obj) {
            if (typeof(obj) === typeId) {
                return matcher.apply(this, arguments)
            }
            return false
        }
    },

    scheme: function (matcher, scheme) {
        return function (obj) {
            if (typeof(obj) !== "object") {
                return false
            }
            for (var i in scheme) {
                if (i in obj) {
                    var target = obj[i]
                    var source = scheme[i]
                    var sourceType = typeof(source)
                    if (sourceType === "string") {
                        if (source === "any" || source == typeof(target)) {
                            continue
                        }

                        return false
                    }

                    if (source !== target) {
                        return false
                    }
                }
                else {
                    return false
                }
            }
            return matcher.apply(this, arguments)
        }
    }
}

/**
 * Creates pattern matching function that accepts the pattern given.
 * The latter combined patterns takes priority over the previously declared ones.
 * @param pattern Pattern to match the target object.
 * @param callback User-defined callback to accept target object as well as the accompanying arguments.
 * @param prevMatcher Previous matcher function created by combine method or null or undefined.
 * @returns Matcher function to be used as follows: matcher.call(objectToBeMatched, optionalArguments...).
 */
pm.combine = function(pattern, callback, prevMatcher) {
    var matcher = function() {
        callback.apply(this, arguments)
        return true
    }

    // join visitor function according to the pattern given
    for (var i in pattern) {
        if (!(i in pm._matcherConstructors)) {
            throw new Error("unexpected pattern tag: " + i)
        }

        matcher = pm._matcherConstructors[i](matcher, pattern[i])
    }

    // if prev matcher either undefined or null - create new function
    if (prevMatcher == null) {
        return matcher
    }
    else {
        return function() {
            if (matcher.apply(this, arguments)) {
                return true
            }
            return prevMatcher.apply(this, arguments)
        }
    }
}

/**
 * Helper function that initializes matcher for all the types of objects with
 * the callback that throws an error.
 */
pm.unknownObjectMatcher = function() {
    throw new Error("unknown object matched")
}

let length(list) = 
  | x::xs -> 1 + length(xs)
  | [] -> 0

// псевдокд JS:

var transform_link = function ( {link:{uri:x1,title:x2}} ) {
    return make_link_helper(x1,x2);
};

-- реальный Hyperlua код:

local fun transform_link
  | {link = {uri = x1, title = x2}} -> make_link_helper(x1,x2)
end

-- Lua код после компиляции (`#x' это length(x), `~=' значит "неравно") :

local function transform_link(_u0)
  if type(_u0)=='table' and #_u0==0 and _u0.link~=nil and
     type(_u0.link)=='table' and #_u0.link==0 and
     _u0.link.uri~=nil and _u0.link.title~=nil
  then
    return make_link_helper(_u0.link.uri, _u0.link.title)
  else error'pattern-match error'
  end
end

var obj = ...
if( test(obj, pattern1) ) ...;
else if( test(obj, pattern2) ) ...;
else if( test(obj, pattern3) ) ...;

ВВ>let length(list) = 
ВВ>  | x::xs -> 1 + length(xs)
ВВ>  | [] -> 0
ВВ>

function length(elem)
{
  return elem? 
     1 + length( elem.next ):
     0;
}

JSON:

{ "line": { "p1": {"x":2, "y":3},
            "p2": {"x":4, "y":5} }}

JSONT:

{ "self": "<svg>{line}</svg>",
  "line": "<line x1=\"{$.p1.x}\" y1=\"{$.p1.y}\"" +
                "x2=\"{$.p2.x}\" y2=\"{$.p2.y}\" />" }


RESULT:
<svg><line x1="2" y1="3"x2="4" y2="5" /></svg>

%% [] -> список/массив
%% {} -> кортеж (тупл)
%% с маленькой буквы — атомы, http://www.trapexit.org/Atom
%% с большой буквы — переменные
%% последняя строка в функции является ее возвращаемым значением
%% _ — это placeholder на случай, если значение нам не нужно

parse_data(Data) ->
    self(Data).    

self(Data) ->
    %% строк в Erlang'е нет, есть списки
    ["<svg>", elements(Data) ,"</svg>"].

%% Head содержит первый элемент
%% Tail — остаток списка
elements([Head|Tail]) ->
    [element(Head), elements(Tail)].


%% принимаем только структуру вида
%% {line, {p1, {X1, Y2}},
%%        {p2, {X2, Y2}}}
%% при этом значения координат сразу закидываем
%% в соответствующие переменные (X1, X2, Y1, Y2)

element({line, {p1, {X1, Y2}},
               {p2, {X2, Y2}}}) ->
    ["<line x1=\"", X1, "\" y1=\"", Y1, "\" x2=\"", X2, "\" y1=\"", Y2, "\" />"];

%% принимаем только структуру вида
%% {circle, {center, {X, Y}},
%%          {radius, R}}
%% при этом значения координат сразу закидываем
%% в соответствующие переменные (X, Y, R)

element({circle, {center, {X, Y}},
                 {radius, R}}) ->
    ["<circle x=\"", X, "\" y=\"", Y, "\" r=\"", R, "\" />"];

%% любые другие элементы просто пропускаем
element(_) ->
    "".

[
   {line, {p1, {0, 0}},
          {p2, {10, 10}}},
   {line, {p1, {0, 0}},
          {p2, {-10, 10}}},
   {circle, {center, {0, 0}},
            {r, 5}},
   {line, {p1, {10, 0}},
          {p2, {-10, -10}}}
]

%% данные
%% ["red", "green", "blue"]
%% результат:
%% <ul>
%%  <li>red</li>
%%  <li>green</li>
%%  <li>blue</li>
%% </ul>

parse_data(Data) -> self(Data).

self(Data) - > ["<ul>", elements(Data), "</ul>"].

elements([Head|Tail]) ->
    [element(Head), elements(Tail)].

element(E) -> ["<li>", E, "</li>"].

%% или, еще проще с list comprehensions:
%% self(Data) - > [
%%     "<ul>"
%%   , [["<li>", E, "</li>"] || E <- Data]
%%   , "</ul>"
%% ].

{ "color": "blue",
  "closed": true,
  "points": [[10,10],[20,10],[20,20],[10,20]] }

+

{ "self": "<svg><{closed} stroke=\"{color}\" points=\"{points}\" />"+
          "</svg>",
  "closed": function(x){return x ? "polygon" : "polyline";}, 
  "points[*][*]": "{$} " }
=

<svg><polygon stroke="blue" points="10 10 20 10 20 20 10 20 " /></svg>

Data = {
    {color, "blue"},
    {closed, true},
    {points, [[10,10],[20,10],[20,20],[10,20]]}
}.

parse_data(Data) -> self(Data).

self(Data) -> ["<svg>", elements(Data) ,"</svg>"].

% тут варианты извращений, все можно сделать проще, естественно :)
elements({Color, Closed, Points}) ->
    ["<", type(Closed), stroke(Color), points(Points), "/>"].

closed({closed, true}) ->
    "polygon ";
closed(_) ->
    "polyline ";

stroke({color, Color}) ->
    ["stroke=\"", Color, "\" "];

%% одна функция points разбирает принципиально разные структуры данных
points({points, Point}) ->
    ["stroke=\"", points(Points), "\" "];

points([[X, Y]|T]) ->
    [X, Y, points(T)].