Ich habe über FRP gelesen und war sehr aufgeregt. Es sieht gut aus, so dass Sie mehr Code auf hoher Ebene schreiben können, und alles ist komponierbarer und so weiter.

Dann habe ich versucht, mein eigenes kleines Spiel mit ein paar hundert Slocs von Plain Js bis Bacon umzuschreiben.

Und ich fand heraus, dass ich, anstatt nur logischen Code auf hoher Ebene zu schreiben, tatsächlich mit Bacon.js und seiner Einhaltung von Prinzipien zu kämpfen habe.

Ich habe Kopfschmerzen, die vor allem sauberen Code stören.

.take(1)

nstatt Wert zu bekommen, sollte ich hässliche Konstruktionen erschaffe

reisförmige Abhängigkeit

Manchmal sollten sie logisch sein. Aber die Implementierung in FRP ist beängstigend

Aktiver Zustand

Selbst Schöpfer von bacon.js haben Probleme damit

Als Beispiel sehen Sie hier den Code, der das Problem demonstriert:

Aufgabe ist es, nicht zuzulassen, dass zwei Spieler am selben Ort bleiben.

Implementiert mit 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);

Was ich demonstrieren möchte ist:

me.positions Abhängigkeit von sich selbst haben Es ist nicht leicht, diesen Code zu verstehen.Hie ist eine zwingende Implementierung. Und es sieht viel einfacher zu verstehen aus. Ich habe viel mehr Zeit mit der Implementierung von Speck verbracht. Und im Ergebnis bin ich mir nicht sicher, ob es wie erwartet funktioniert.Meine Frage

Wahrscheinlich vermisse ich etwas grundlegendes. Vielleicht ist meine Implementierung nicht so im FRP-Stil?

Möglicherweise sieht dieser Code in Ordnung aus und ist mit dem neuen Codierungsstil nicht vertraut?

Oder diese bekannten Probleme, und ich sollte am besten von allem Übel wählen? Also Probleme mit FRP wie beschrieben, oder Probleme mit OOP.