Snapshot + listen

[dakom]

There's no shortcut for snapshot+listen right?

I have something like this:

sUpdate
        .snapshot(cIoUpdates, (...args) => args)
        .listen(processArgs);

It's not so bad of course, really not a big deal at all, but it could be nicer to avoid that (...args) => args. If I put processArgs there then I'd need a "dummy listener" which feels worse to me.

[clinuxrulz]

You can use snapshot to create a zero param closure representing the side effect, then execute that closure in listen.

E.g.

sUpdate
        .snapshot(cIoUpdates, (...args) => () => processArgs(args))
        .listen(effect => effect());

I don't know typescript so the above syntax is a guess.

There is a function I've seen before in another frp library:

actuate :: Stream (IO ()) -> Listener which does just that. (IO () is our zero param side effecting closure). It could be a handy utility.

If we had actuate, then the code becomes:

sUpdate
        .snapshot(cIoUpdates, (...args) => () => processArgs(args))
        .actuate();

[dakom]

Hmm thanks! I'd love to integrate more traditional FP techniques into my code.

Can you elaborate a little more on the benefits here? The functional wrapper doesn't seem to add much versatility in this case, and it is a bit more code to read. If it's hard to demonstrate in a short example that's cool too - I get that some things only show their benefits on larger sorts of problems.

[clinuxrulz]

For starters, we can should only do a pure calculation inside snapshot, and do the side effect inside listen. So we are forced to do it in two phases. One advantage I can think of is that, for languages that do not have good support for variadic arguments, you can save on packing and unpacking all your parameters together.

E.g.

listener =
    sMouseDown
        .snapshot(
            cMousePos,
            (mouseBtn, mousePos) => () => {
                /* do an effect with the params */
            }
        )
        .actuate()

You can see above that mouseBtn and mousePos can be used in the side effect directly without packing, then unpacking the parameters. It is a lot more useful in Java, because Java does not have any tuples in their standard API. You have to roll your own tuples or use a library.

I suppose also, if you avoid using ...args in TypeScript and follow the example above, you can gain some extra type safety, because I'd imagine ...args is dynamically typed.

[dakom]

Thanks!

I suppose also, if you avoid using ...args in TypeScript and follow the example above, you can gain some extra type safety, because I'd imagine ...args is dynamically typed.

Yeah... I don't think there's a way to inherently have the type inference work there, though it can be typed manually, destructured with types, etc.