Very simple observable implementation

observable.js

function Observable(observe) {
    this.map = f => {
        return new Observable(cb => {
            this.observe(x => {
                cb(f(x));
            });
        });
    }

    this.flatMap = f => {
        return new Observable(cb => {
            this.observe(x => {
                f(x).observe(cb);
            });
        });
    }

    this.flatten = () => {
        return this.flatMap(x => x);
    }

    this.zip = obs => {
        var thisCur = undefined;
        var otherCur = undefined;

        return new Observable(cb => {
            this.observe(x => {
                thisCur = x;
                cb([thisCur, otherCur]);
            });
            obs.observe(x => {
                otherCur = x;
                cb([thisCur, otherCur]);
            })
        });
    }

    this.filter = f => {
        return new Observable(cb => {
            this.observe(x => {
                if(f(x)) {
                    cb(x);
                }
            })
        })
    }

    this.delay = t => {
        return new Observable(cb => {
            this.observe(x => {
                window.setTimeout(() => {
                    cb(x);
                }, t);
            });
        });
    }

    this.debounce = t => {
        var lastHandle = undefined;
        return new Observable(cb => {
            this.observe(x => {
                if(lastHandle !== undefined) {
                    clearTimeout(lastHandle);
                }
                lastHandle = window.setTimeout(() => {
                    cb(x);
                }, t);
            });
        });
    }

    this.repeat = t => {
        return new Observable(cb => {
            this.observe(x => {
                cb(x);
                window.setInterval(() => {
                    cb(x);
                }, t);
            });
        });
    };

    this.fold = (f,z) => {
        var curr = z;
        return this.map(x => {
            curr = f(curr,x);
            return curr;
        })
    }

    this.observe = cb => {
        var listening = true;
        observe(x => {
            if(listening) {
                cb(x);
            }
        });
        return () => {
            listening = false;
        };
    }
}

Obs = {
    from: x => {
        return new Observable(cb => {
            cb(x);
        })
    },

    delayed: (x, time) => {
        return Obs.from(x).delay(time);
    },

    repeated: (x, time) => {
        return Obs.from(x).repeat(time);
    }
}

sequence = ls => {
    if(ls.length === 0) {
        return Obs.from([]);
    } else {
        return ls[0]
            .zip(sequence(ls.splice(1)))
            .map(l => [l[0]].concat(l[1]))
            .filter(ls => ls.every(x => x !== undefined));
    }
}

fromEvent = (domElem, ev) => new Observable(cb => {
    domElem.addEventListener(ev, (doc) => cb(doc));
});

var move = fromEvent(document, "mousemove");

var t = move.debounce(300).fold((a,b) => a+1,0).observe(x => console.log(x))