add more dependency for existing combine

[futurist]

I have a problem when use combine:

const sum = (...args) => args.slice(0,-2).reduce((acc,f)=>acc+f(), 0)
const arr = Array(3).fill(1).map(flyd.stream)
const result = flyd.combine(sum, arr)
result.map(console.log)

arr.push(flyd.stream(10))
// how to sum the 4th stream?

I want to push new value into arr, and want sum the 4 arr elements instead of 3.

That is, a question, how to modify existing combine dependency?

[nordfjord]

You have a number of options but the one I'd recommend would be to use chain.

It allows you to take a Stream of Streams and get a stream.

An example using Ramda's liftN function:

const streams$ = flyd.stream(Array(3).fill(1).map(flyd.stream));
const sum = (...args)=> args.reduce((a,b) => a + b, 0);
const result = streams$
  .chain((streams)=> R.liftN(streams.length, sum)(...streams))
result.map(console.log);
// Logs: 3
streams$(streams$().concat([flyd.stream(10)]));
// Logs: 13

[nordfjord]

@futurist Was the above helpful?

[futurist]

@nordfjord Thanks for the example and solution, it's works great for this example. Can i understand chain can be a replacement for combine? what's the usage scenario of differents for chain and combine normally?

[nordfjord]

You can think of combine as the low level flyd operator. It's mainly used to create other operators.

e.g. filter could be implemented as:

const filter = fn => stream => combine((s, self)=> {
  if (fn(s.val)) self(s.val);
}, [stream]);

const number$ = stream();
const above5$ = number$.pipe(filter(n => n > 5));
above5$.map(console.log);

number$(3);
// Logs nothing
number$(7)
// Logs: 7

Map is also be implemented using combine:

const map = fn => s => combine((s,self)=> self(fn(s.val)), [s]);

If we think of the signatures of the functions map, and chain then map is:

map :: (a -> b) -> Stream a -> Stream b

And chain is:

chain :: (a -> Stream b) -> Stream a -> Stream b

This means chain can be used when you have a function that takes a value and returns a stream. You can think of it as flatMap

[futurist]

I'm writting a lib wrap-data, and need a validation in the model, it has an isEmpty field and need to combine other streams dynamically, like below:

const flyd = require('flyd')
const wrapData = require('wrap-data')
const data = {
    firstName: 'Hello',
    lastName: 'World',
    age: 20,
}
const model = wrapData(flyd.stream)(data)
// model, and everything inside model is a stream!

model.set('isEmpty', flyd.combine( checkEmtpy, [
    model.get('age'), model.get('firstName'), model.get('lastName')
] ))

Here the need is name is optional, if firstName is empty then checkEmpty will ignore all name field. But if firstName not empty then lastName can not empty.

This need some dynamic combine or chain, add more stream or subtract some stream from the combine list.

[nordfjord]

I'm not sure how to help you with that, I might suggest another approach.

const checkEmpty = ({firstName, lastName, age})=> firstName 
  ? firstName && lastName && age > 0
  : age > 0;

const model = stream({
  firstName: 'Hello',
  lastName: 'World',
  age: 20
});

model.isEmpty = model.map(checkEmpty);

model.isEmpty() // false

model(Object.assign({}, model(), {lastName: ''}));

model.isEmpty() // true

[nordfjord]

Hello again @futurist I have been thinking about your problem for a while, but last night a solution hit me that might fit into your frame!

import { stream } from 'flyd';

// (...any[] -> any) -> Stream Stream[] -> Stream any
const dynamicCombine = (fn, streams$)=> streams$ 
  .chain(streams => combine(fn, streams));

Now I'm not familiar with the internals of your library, but if you're able to instead of using a List<Stream> to host the "fields" of the model, and move to Stream<List<Stream>> then this would solve your problem.