Add fluent API

Often it’s really annoying to rewrite long chained operations in an functional style. The https://github.com/mindeavor/es-pipeline-operator would help with this when it arrives, but for now, expressions like flyd .on (..., filter (..., filter (..., target_range)) .map (...)) are absolutely unreadable, especially with complex functions in between. I switched from most.js, and their style of target_range .filter (...) .filter (...) .map (...) .observe (...) is much more pleasing and easier to use. I propose to add the following line to amend this problem.

function createStream() {
  function s(n) {
    if (arguments.length === 0) return s.val
    updateStreamValue(s, n)
    return s
  }
  s.hasVal = false;
  s.val = undefined;
  s.vals = [];
  s.listeners = [];
  s.queued = false;
  s.end = undefined;
  s.map = boundMap;
  /*fluent api*/s.thru = function (thru) { return thru (s); };
  s.ap = ap;
  s.of = flyd.stream;
  s.toString = streamToString;
  return s;
}

or perhaps

function createStream() {
  function s(n) {
    if (arguments.length === 0) return s.val
    updateStreamValue(s, n)
    return s
  }
  s.hasVal = false;
  s.val = undefined;
  s.vals = [];
  s.listeners = [];
  s.queued = false;
  s.end = undefined;
  s.map = boundMap;
  /*fluent api 2*/s.thru = function (func, args) { return func .apply (s, [] .concat .call (args || [], [s])); };
  s.ap = ap;
  s.of = flyd.stream;
  s.toString = streamToString;
  return s;
}

Which would also allow usages like stream.thru(filter,[isOdd]).map(square).thru(flyd.transduce, R.take(5))

[squiddle]

I second with @StreetStrider to use Ramda.pipe (equivalent to _.flow) and currying in this situation. flyd already has a data/stream in last position API.

The code layout becomes nearly same as with fluent apis, but gets the additional benefit of being more declarative without introducing a feature coming from an OOP style.

const flydFilter = require('paldepind/flyd-filter');

R.pipe(
  flydFilter(isOdd), 
  flyd.map(square), 
  flyd.transduce(R.take(5))
)(stream);

[paldepind]

When I wrote Flyd I was very much against methods. But these days I definitely think that fluent APIs do have their benefits.

I think the biggest issue is that Flyd tries to be modular. But, with a fluent API all methods will have to be available at the prototype.

I think @squiddle’s suggestion of using R.pipe is nice. It sorta achieves the same thing as the pipeline operator.

@StreetStrider

There was a package that allows to turn any fp-interface to fluent, but I can’t find it in my stars, nor in @paldepind stars. There was a mention of it somewhere, but I can’t find id, so sad. It takes and object of functions (data-last functions) which would create fluent interface and returns wrapper object which contains all context with context-bounded version of functions. This may be a possible solution for you.

That sounds very interesting! Definitely share it if you find it.