Eu li sobre FRP e fiquei muito animado. Parece ótimo, para que você possa escrever mais código de alto nível, e tudo seja mais compostável, etc.

Depois, tentei reescrever meu próprio joguinho com algumas centenas de sloc de js simples para Bacon.

E descobri que, em vez de escrever código apenas de lógica de alto nível, eu realmente batia com o Bacon.js e sua aderência aos princípios.

Eu me deparo com uma dor de cabeça que interfere principalmente no código limpo

.take(1)

Em vez de obter valor, devo criar construções feias.

Dependências circulares

Às vezes eles deveriam ser pela lógica. Mas implementá-lo no FRP é assustador

Estado ativo

Até o criador do bacon.js temproblemas com isso.

Como exemplo, aqui está a paz de código para demonstrar o problema:

A tarefa é não permitir que dois jogadores fiquem no mesmo lugar

Implementado com bacon.js

http://jsbin.com/zopiyarugu/2/edit?js,console

function add(a) {return function(b){return a + b}}
function nEq(a) {return function(b){return a !== b}}
function eq(a) {return function(b){return a === b}}
function always(val) {return function(){return val}}
function id(a){return a}

var Player = function(players, movement, initPos){
    var me = {};
    me.position = movement
        .flatMap(function(val){
            return me.position
                .take(1)
                .map(add(val))
        })
        .flatMap(function(posFuture){
            var otherPlayerPositions = players
                .filter(nEq(me))
                .map(function(player){return player.position.take(1)})
            return Bacon
                .combineAsArray(otherPlayerPositions)
                .map(function(positions){
                    return !positions.some(eq(posFuture));
                })
                .filter(id)
                .map(always(posFuture))
        })
        .log('player:' + initPos)
        .toProperty(initPos);
    return me;
}

var moveA = new Bacon.Bus();
var moveB = new Bacon.Bus();

var players = [];
players.push(new Player(players, moveA, 0));
players.push(new Player(players, moveB, 10));

moveA.push(4);
moveB.push(-4);
moveA.push(1);
moveB.push(-1);
moveB.push(-1);
moveB.push(-1);
moveA.push(1);
moveA.push(-1);
moveB.push(-1);

O que eu quero demonstrar é:

me.positions ter dependência por conta própriaNão é fácil entender esse código.Aqui é uma implementação imperativa. E parece muito mais fácil de entender. Passei muito mais tempo com a implementação do bacon. E, como resultado, não tenho certeza de que funcionará conforme o esperado.Minha pergunta:

Provavelmente sinto falta de algo fundamental. Talvez minha implementação não seja tão no estilo FRP?

Talvez esse código pareça ok e não esteja acostumado com o novo estilo de codificação?

Ou esses problemas bem conhecidos, e eu deveria escolher o melhor de todos os males? Então, problemas com FRP, como descrito, ou problemas com OOP.