Thoughts on reactive implementation

reactive.js

function compose (...funcs) {
  if (funcs.length <= 0) {
    return x => x
  }
  if (funcs.length === 1) {
    return funcs[0]
  }

  const innerFunc = funcs[funcs.length - 1]
  const restFunc = funcs.slice(0, -1)
  const reducer = (res, fn) => fn(res)

  return function composed (...args) {
    return restFunc.reduceRight(reducer, innerFunc(...args))
  }
}

function curry (fn, ...args) {
  return args.length === fn.length
    ? fn(...args)
    : (...nextArgs) => curry(fn, ...args, ...nextArgs)
}

const map = curry(function (mapper, next, v) {
  next(mapper(v))
})

const filter = curry(function (predicate, next, v) {
  if (predicate(v)) {
    next(v)
  }
})

function interval (callback) {
  let i = 0
  setInterval(() => callback(i++), 1000)
}

function logNum (num) {
  console.log(num)
}

const subscribe = compose(
  map(x => x * 3),
  filter(x => x <= 10)
)

interval(subscribe(logNum))