Proposal to add `fromProperty` static function

I find myself wanting to throttle/debounce properties quite often. One example where it seems absolutely necessary – SSR. You need to wait until your state somehow stabillizes to make a snapshot of it for rendering.

1. state$.throttle() / state$.debounce() don’t fit because they pass initial value through a time-based gateways. I mentioned that here https://github.com/kefirjs/kefir/issues/278

2. state$.changes().throttle(), etc. don’t fit because they lose initial value completely.

I propose to add the following function to the standard toolkit:

function fromProperty(prop$) {
  return K.merge([K.later(0, prop$.take(1)).flatMap(), prop$.skip(1)])
}

---

Demo case:

let K = require("kefir")

let makeStore = (seed, action$) => {
  return action$
    .scan((z, fn) => fn(z), seed)
    .skipDuplicates()
}

let action$ = K.later(250, z => z + 1) // also try: K.never()

let state$ = makeStore(1, action$)

function fromProperty(prop$) {
  return K.merge([K.later(0, prop$.take(1)).flatMap(), prop$.skip(1)])
}

fromProperty(state$)
  .throttle(500, {leading: false}) // ---2| or ---1|
  .log("state$") // both async and initial values are throttled / debounced properly

[mAAdhaTTah]

(I’m assuming a lot about your use case, so please correct me where I’m wrong.)

Thinking about this more, if you’re determining that you state has stabilized as a factor of time, it feels a bit Doing It Wrong™. Expressing it as “state has stabilized after receiving no updates after Xms” doesn’t capture the relationship between a “stable state” & whatever other tasks are responsible for stabilizing it. You’re expressing the relationship implicitly through time, rather than directly through the streams themselves.

I would approach the issue one of two ways (I’m assuming your approach is Redux-like, which I have a decent amount of experience in):

1. Express the dependency directly via flatMap and friends. When all of them end, emit the single value that results.

2. Express the dependency through the state itself, e.g. if you have 4 tasks that need to finish before emitting the state, then having state.tasks.competed = 0 and incrementing that as they complete, then doing something like:

   state$.filter(state => state.tasks.completed >= 4).take(1)
   

   would express that as well.

Thoughts?

[ivan-kleshnin]

Hmm, another very interesting idea. I totally forgot about this possibility. More kudos to you! 👏