Allow lazy seed for the scan operator?

[josepot]

Hi,

In some situations it can be beneficial to have a lazy seed for scan. For instance, consider this contrived example:

const myObservable$ = source$.pipe(
  scan((acc, event) => {
    if (event.type === 'set') {
      acc.set(event.payload.id, event.payload)
    } else {
      acc.delete(event.payload.id)
    }
    return acc
  }, new Map()),
  map(entries => Object.fromEntries([...entries]))
)

In this example the scan operator is mutating its accumulator, which looks like a horribly dangerous thing to do 😱. However, the map enhancer ensures that the output of myObservable$ is an immutable data-structure, so in the end maybe that's not that bad, right?

But it is, because now if we unsubscribe from myObservable$ the garbage collector won't be able to clean that Map that we have been mutating, therefore creating a memory-leak. And what's even worse is that if we unsubscribe and later we subscribe again, then the new observer will receive the stale values from the previous observer. So, yeah, as of today mutating the accumulator is always a bad idea...

However, if we allowed for a lazy seed, then we could do this:

const myObservable$ = source$.pipe(
  scan((acc, event) => {
    if (event.type === 'set') {
      acc.set(event.payload.id, event.payload)
    } else {
      acc.delete(event.payload.id)
    }
    return acc;
  }, () => new Map()),
  map(entries => Object.fromEntries([...entries]))
)

Which, sure, it looks bad and it's not not a pattern that we would want to promote, of course, but in some cases it can be ergonomic to allow for mutations inside the scan operator, because it can be further improved with an operator that ensures that the result is going to be an immutable data-structure...

Thoughts?

The big caveat with this is that this would be a breaking change, because maybe there are cases where the seed value is actually a function, so in those (probably very rare) cases, the only way to pass a function to the accumulator would be to use the lazy seed to return a function.

[cartant]

Wrap it in defer:

const myObservable$ = defer(() => source$.pipe(
  scan((acc, event) => {
    if (event.type === 'set') {
      acc.set(event.payload.id, event.payload)
    } else {
      acc.delete(event.payload.id)
    }
    return acc
  }, new Map()),
  map(entries => Object.fromEntries([...entries])
))

[josepot]

Thanks @cartant ! Yes, defer does the trick, and I'm pretty sure that there are other ways as well... like not passing the initial seed to scan and making sure that the source always emits first a new map and then the rest of the stuff (good luck at getting the types right with that one, though 😅). So, yes, I was exaggerating when I said that "as of today mutating the accumulator is always a bad idea".

However, IMO a lazy seed is more ergonomic than wrapping the whole pipe with a defer. Anyways, it's just an idea. Although, I realize that if no one has requested this until today it's probably because it's not really needed.

[cartant]

The thing is, though, is that laziness is what the defer creator is for. It can be used to make any composed observable lazy, so you could use it with startWith, endWith, etc. You could use it to make a Promise lazy. IMO, this is preferable to putting factories everywhere to the facilitate lazy creation of values. (BTW, I updated my snippet to remove the inline-operator business. IDK what I was thinking there. 🤦‍♂️)