The JavaScript Pipeline Operator

Post by _uhtu » Thu, Nov 08, 2018, 6:03 PM UTC

hajile wrote: post #51

_uhtu wrote: post #32

Earlier quoted context omitted.

I disagree. ES6 made JS much more palatable but it's still behind most modern languages in terms of number of features and in velocity of new features getting introduced. Javascript has actually been extremely slow to get new features compared to other languages. Since ES6 (3 years ago), the only major, mainstream feature that has been added to JS has been async functions, which are awesome, but in that time Python (…

> I disagree. ES6 made JS much more palatable but it's still behind most modern languages in terms of number of features and in velocity of new features getting introduced. Javascript has actually been extremely slow to get new features compared to other languages. JS has been adding features at a tremendous rate. Several major features land every year. Adding something like async generators is a huge change that aff…

Post by piedar » Thu, Nov 08, 2018, 6:58 PM UTC

ConcernedCoder wrote: post #50

mbostock wrote: post #28

You don’t need lodash or a new operator for the example provided: departments .flatMap(d => d.employees) .map(e => e.salary) .reduce((p, v) => Math.max(p, v), 0) That said, the pipe operator is nice because it allows similar chaining patterns on subjects that are not arrays, as shown in the proposal’s README: https://github.com/tc39/proposal-pipeline-operator/blob/mast...

That's all well and good ( increasing readability ) but the problem remains that each step has to finish before the next step can begin... sometimes the entire dataset won't fit into memory/machine/whatever... More useful, IMHO, would be a way to EASILY compose a true pipeline: const _pipe = (a, b) => (arg) => b(a(arg)), pipe = (...ops) => ops.reduce(_pipe) ...but have the behavior work like unix pipes ( a stream ),…

    import { query } from 'itiriri';

    function* fibonacci() {
       let [a, b] = [0, 1];

      while (true) {
        yield a;
        [a, b] = [b, a + b];
      }
    }

    // Finding first 3 Fibonacci numbers that contain 42
    const result = query(fibonacci())
      .filter(x => x.toString().indexOf('42') !== -1)
      .take(3);

    for (const e of result) {
      console.log(e);
    }

    // outputs: 514229, 267914296, 7778742049

Post by dvlsg » Thu, Nov 08, 2018, 8:07 PM UTC

piedar wrote: post #54

ConcernedCoder wrote: post #50

Earlier quoted context omitted.

That's all well and good ( increasing readability ) but the problem remains that each step has to finish before the next step can begin... sometimes the entire dataset won't fit into memory/machine/whatever... More useful, IMHO, would be a way to EASILY compose a true pipeline: const _pipe = (a, b) => (arg) => b(a(arg)), pipe = (...ops) => ops.reduce(_pipe) ...but have the behavior work like unix pipes ( a stream ),…

Have you seen https://github.com/labs42io/itiriri ? It does lazy queries on iterables, like IEnumerable from C#. import { query } from 'itiriri'; function* fibonacci() { let [a, b] = [0, 1]; while (true) { yield a; [a, b] = [b, a + b]; } } // Finding first 3 Fibonacci numbers that contain 42 const result = query(fibonacci()) .filter(x => x.toString().indexOf('42') !== -1) .take(3); for (const e of result) { console.l…

Post by hajile » Thu, Nov 08, 2018, 9:33 PM UTC

_uhtu wrote: post #52

hajile wrote: post #51

Earlier quoted context omitted.

> I disagree. ES6 made JS much more palatable but it's still behind most modern languages in terms of number of features and in velocity of new features getting introduced. Javascript has actually been extremely slow to get new features compared to other languages. JS has been adding features at a tremendous rate. Several major features land every year. Adding something like async generators is a huge change that aff…

You say "Several major features land every year.", but you don't back that up. In 2018 the major features we got object rest/spread and asynchronous interation. Rest/spread is a big feature that I forgot to mention, but async iteration is only useful in a few situations, I'd call it a minor feature. In 2017 we got async/await, and shared memory/atomics. Only a few fringe code bases will use shared/memory/atomics, so…

Post by nabla9 » Fri, Nov 09, 2018, 2:51 PM UTC

AndrewDucker wrote: post #36

nabla9 wrote: post #8

>The difference is in how we read it. With pipeline operator data flows from left to the right, and thus making it much more comprehensible without the need to introduce extra variables. Why you need operator? Can't it be done with a function? pipe(64,Math.sqrt)

And if you have 10 of them in a row then you have: pipe(pipe(pipe(pipe(pipe(pipe(pipe(pipe(pipe(pipe(64,sqrt),add),divide),subtract,....) I don't know about you, but I wouldn't want to debug that.

    function pipe(...args) { }

    pipe(64,sqrt,add,divide,subtract)