He leído sobre FRP y estaba muy emocionado. Se ve muy bien, por lo que puede escribir más código de alto nivel, y todo es más componible, etc.

Luego traté de reescribir mi propio pequeño juego con unos pocos cientos de sloc desde JS hasta Bacon.

Y descubrí que, en lugar de escribir código lógico de alto nivel, en realidad estaba superando a Bacon.js y su adhesión a los principios.

Me encuentro con un dolor de cabeza que interfiere principalmente en el código limpio

.take(1)

En lugar de obtener valor, debería crear construcciones feas.

Dependencias circulares

A veces deberían ser por lógica. Pero implementarlo en FRP da miedo

Estado activo

Incluso creador de bacon.js tienenubes con eso.

Como ejemplo, aquí está la paz del código para demostrar el problema:

La tarea es no permitir que dos jugadores se queden en el mismo lugar.

Implementado con 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);

Lo que quiero demostrar es:

me.positions tener dependencia propiaNo es fácil entender este código.aquí Es una implementación imprescindible. Y parece mucho más fácil de entender. Pasé mucho más tiempo con la implementación de tocino. Y como resultado, no estoy seguro de que funcione como se esperaba.Mi pregunta:

Probablemente extraño algo fundamental. ¿Quizás mi implementación no es tan en estilo FRP?

¿Tal vez este código se ve bien, y simplemente no está acostumbrado con el nuevo estilo de codificación?

¿O estos problemas bien conocidos, y debería elegir el mejor de todos los males? Entonces, problemas con FRP como se describe, o problemas con OOP.