function blackMagic(x, y, z) {
  return x + y *z;
}

//Knockout:
var x = ko.observable(5);
var y = ko.observable(7);
var z1 = ko.computed(function() {
  return blackMagic(x.value(), 42, y.value());
});
var z2 = ko.computed(function() {
  return blackMagic(4, x.value(), x.value());
});

//Mine:
var x = R.variable(5);
var y = R.variable(7);
var z1 = R.apply(blackMagic, [x, 42, y]);
var z2 = R.apply(blackMagic, [4, x, x]);

function f1(x, y) {
  return 2 * x + y;
}
function f2(x, y) {
  return x - y + 4;
}
var a = R.variable(1);
var b = R.apply(f1, [a, 3]);
var c = R.apply(f2, [a, 9]);
var res = R.apply(f1, [b, c]);
R.apply(alert, [res]); 
// Сколько будет алертов при вычислении следующей строки:
a.set(10);

// Какие-то глобальные (или долгоживущие) observable.
var globalA, globalB;

// Временный scope (например, диалоговое окно)
var session = R.session();
var x = R.variable(123);
var a = session.proxy(globalA);
var b = session.proxy(globalB);
var y = R.apply(fn, [a, b, x]);
//...
// При закрытии окна
session.destroy();

vsb>А MVC хорошего как не было, так и нет нигде

var x = Behavior.variable(3);
var y = Behavior.variable(5);

function calc(x, y, z) {
  return x + y * z;
}

var res = Behavior.apply(calc, [x, y, 7]);
var elt = UI.div(UI.text(res));
Behavior.appply(alert, res);

x.set(10);
y.set(20);

function filter(spec, items) {
  var res = [];
  items.foreach(function(item) {
    if (item.firstName == spec.firstName && item.lastName == spec.lastName)
      res.append(item);
  });
  return res;
}

function mkSpec(firstName, lastName) {
  return { firstName : firstName, lastName : lastName };
}

var firstName = ...
var lastName = ...
var allItems = ...

var itemsToShow = Behavior.apply(filter, [Behavior.apply(mkSpec, [firstName, lastName]), allItems]);
var itemPages = Behavior.apply(paginate, [itemsToShow]);
var pageToDisplay = Behavior.apply(Arrays.itemAt, [itemPages, currentPage]);

namespace KindOfModel {
  var x = 5;
  var y = 7;
  var z1,z2;
  
  @observing "x" "y"  
    function() { z1 = x + y + 42; }

  @observing "x" 
    function() { z2 = 2 * x + 42; }
}

<form model="KindOfModel">
  <label>X</label> <input(x)>
  <label>Y</label> <input(y)>
  Z1: <output(z1)> and Z2 <output(z2)>
</form>

var group = Async.group();
var preop1 = group.add(startPreop1());
var preop2 = group.applyAsync(startPreop2, [preop1]);
var preop3 = group.applyAsync(startPreop3, [preop2]);
var ajaxQuery = group.applyAsync(doLongLastingOp, [preop3]);
var postOp1 = group.applyAsync(startPostOp1, [ajaxQuery]);
var postOp2 = group.applyAsync(startPostOp2, [postOp1]);
var postOp3 = group.applyAsync(startPostOp3, [postOp2]);

R.apply(function(state) {
  switch (state.state) {
    case 'progress' :
      console.log('Progress is ' + state.progress);
  }
}, [group.progress]);

// cancellation:
group.cancel();

// functions:
function startPreop2() {
  // Staightfroward. between ajax and async API.
  return Net.call(....);
}

Async.group = function() {
  // Observable array.
  var ops = R.Arrays.variable();
  // Observable array of observables!
  var progresses = R.Arrays.mapValues(ops, function(op) {
    // Это будет behavior!
    return op.progress;
  });
  // Observable array of "progress values"
  var flatProgresses = R.Arrays.flatten(progresses);
  // Create behaviour which is sum of all progresses in the 
  // observable array (reduce operation).
  var totalProgress = R.Arrays.reduce(flatProgresses, 0, function(sum, state) {
    switch(state.state) {
      case 'progress': return sum + state.progress;
      case 'success' : return sum + 1;
      case 'error' : return sum;
      default: return sum; // log error
    }
  });
  var totalElems = R.Arrays.lenghtBehaviour(flatProgresses);
  // Среднее арифметическое, допустим, мы так считаем прогресс.
  var progress = R.apply(function(prog, count) {
    return count > 0 ? prog / count : 0;
  }, [totalProgress, totalElems]);
  
  return {
    'add' : function(op) {
      ops.push(op);
    },
    'applyAsync' : function() {
      var op = Async.applyAsync(arguments[0], arguments.slice(1));
      ops.push(op);
      return op;
    },
    'progress' : progress,
    'cancel' : function() {
      ops.foreach(function(op) { op.cancel(); });
    }
  }
}

• reactive programming (core) — 3-5 дней (я за один-два пишу уже)
  
• async wrappers (using reactive) — 3-5 дней (тоже один/два по коду, но нужно приличное reactive programming и еще дополнительное время на выяснение требований (специфичных для данного конкретного проекта)).
  
• UI core ~ 3 дня для первых экранов, еще пару дней растянуто на 2-4 недели (пишется по мере необходимости).
  
• Advanced UI 3-5 дней, растянуто по сроку жизни проекта (т.е. от месяца до нескольких месяцев).
  
• Networking layers — 3-5 дней. Это всякие фишки, которые умеют выводить сообщения об ошибках и т.п. Мое любимое — предложить пользователю залогиниться и повторить операцию, если у него истекла сессия (без перезагрузки страницы, естественно). Собственно, этот networking layer нужен в любом приложении. Поверх async, promises и т.п. — не важно, все равно писать надо.

// elt будет element
var elt = UI.form(
  UI.label('X'), UI.input(x, x.set),
  UI.label('Y'), UI.input(y, y.set),
  UI.text('Z1: '), UI.text(z1), UI.text(" and Z2 "), UI.text(z2)
);

// Можно использовать и короткую версию для ввода:
UI.input(x) === UI.input(x, x.set)

M>var group = Async.group();
M>

var cancel = new Cancel();
var progress = createProgress([5, 60, 25, 10], parentProgress);
var status = yield ajax('HEAD', url, cancel, progress[0]);

if(status.isValid())
   return Promise.reject(status.toError());

var archive = yield ajax('GET', url, cancel, progress[1]);
var content = yield unpack(archive, progress[2]);
var checksum = yield sha1.get(content, progress[3]);

return Promise.resolve({content:content, checksum:checksum});

var group = Async.group();
var status = call(url, 'HEAD', group, 5);
var statusValue = group.apply(function(status) {
  if (status.isValid())
     throw status.toError();
  return status;
})

var archive = group.applyAsync(call, [url, 'HEAD', group', 60, statusValue]);
var content = group.apply(unpack, [archive], 25);
var checksum = group.apply(sha1.get, [content], 10);

return groupeapply(function(content, checksum) {
  return {content:content, checksum:checksum};
}, [content, checksum], 0);

var op1 = startOp1();
var op2 = startOp2();
var op3 = startOp3();

var opA = Async.applyAsync(doAsyncGood, [op1, op2]);
var opB = Async.applyAsync(doAsyncEvil, [op3, op2]);

return Async.apply(combineGoodAndEvil, [opA, opB]);