如何使用FP的compose（）javascript将两个函数组合成1？

Question

How can I compose two functions together into 1 using FP's compose() here's live code: https://repl.it/JXMl/1

I have 3 pure functions:

// groups By some unique key
const groupBy = function(xs, key) {
  return xs.reduce(function(rv, x) {
    (rv[x[key]] = rv[x[key]] || []).push(x);
    return rv;
  }, {});
};

// ungroups the group by
const ungroup = (obj) => {
  return Object.keys(obj)
               .map(x => obj[x]);
};

// flatten array
const flatten = (arrs) => {
  return arrs.reduce((acc, item) => acc.concat(item), [])
}

And a functional utility compose function from Functional Jargon

const compose = (f, g) => (a) => f(g(a))

In the end, I want a ungroupAndFlatten function created through compose() .

Along the lines of:

const ungroupAndFlatten = compose(ungroup, flatten) // Usage doesn't work.
console.log(ungroupAndFlatten(obj)) 

Example code:

const arrs = [
  {name: 'abc', effectiveDate: "2016-01-01T00:00:00+00:00"},
  {name: 'abcd', effectiveDate: "2016-02-01T00:00:00+00:00"},
  {name: 'abcd', effectiveDate: "2016-09-01T00:00:00+00:00"},
  {name: 'abc', effectiveDate: "2016-04-01T00:00:00+00:00"},
  {name: 'abc', effectiveDate: "2016-05-01T00:00:00+00:00"},
]; 

const groupedByName = groupBy(arrs, 'name');

// Example Output
//
// var obj = {
//    abc: [
//      { name: 'abc', effectiveDate: '2016-01-01T00:00:00+00:00' },
//      { name: 'abc', effectiveDate: '2016-04-01T00:00:00+00:00' },
//      { name: 'abc', effectiveDate: '2016-05-01T00:00:00+00:00' }
//    ],
//    abcd: [ 
//      { name: 'abcd', effectiveDate: '2016-02-01T00:00:00+00:00' },
//      { name: 'abcd', effectiveDate: '2016-09-01T00:00:00+00:00' }
//    ]
//  }

const ungroupAndFlatten = compose(ungroup, flatten) // Usage doesn't work.
console.log(ungroupAndFlatten(groupedByName)) 

// Output:
//  var arrs = [
//    {name: 'abc', effectiveDate: "2016-01-01T00:00:00+00:00"},
//    {name: 'abcd', effectiveDate: "2016-02-01T00:00:00+00:00"},
//    {name: 'abcd', effectiveDate: "2016-09-01T00:00:00+00:00"},
//    {name: 'abc', effectiveDate: "2016-04-01T00:00:00+00:00"},
//    {name: 'abc', effectiveDate: "2016-05-01T00:00:00+00:00"},
//  ];

Answer 1

I believe you made a simple mistake,you've set ungroup as your f function while it is your g function:

const ungroupAndFlatten = compose(flatten, ungroup)

switch ungroup and flatten and everything will work fine

Answer 2

Function Composition

The function compose has a evaluation order from right to left .

/*
 * 1. take x
 * 2. execute g(x)
 * 3. take the return value of g(x) and execute f with it
*/
const compose = (f, g) => x => f(g(x))

There is another function called pipe which evaluates from left to right

const pipe = (g, f) => x => f(g(x))

Your Code

As already mentioned by @Nima Hakimi , you have reversed the argument order.

To solve you problem we could

• switch the order of the arguments

  \nconst ungroupAndFlatten = compose( \n    flatten, \n    ungroup \n) \n

   const compose = (f, g) => x => f(g(x)) const ungroup = obj => Object.keys(obj) .map(x => obj[x]); const flatten = arrs => arrs.reduce((acc, item) => acc.concat(item), []) const groupedByName = { abc: [ { name: 'abc', effectiveDate: '2016-01-01T00:00:00+00:00' }, { name: 'abc', effectiveDate: '2016-04-01T00:00:00+00:00' }, { name: 'abc', effectiveDate: '2016-05-01T00:00:00+00:00' } ], abcd: [ { name: 'abcd', effectiveDate: '2016-02-01T00:00:00+00:00' }, { name: 'abcd', effectiveDate: '2016-09-01T00:00:00+00:00' } ] } const ungroupAndFlatten = compose( flatten, ungroup ) console.log( ungroupAndFlatten(groupedByName) ) 

• or use pipe

  \nconst ungroupAndFlatten = pipe( \n    ungroup, \n    flatten \n) \n

   const pipe = (g, f) => x => f(g(x)) const ungroup = obj => Object.keys(obj) .map(x => obj[x]); const flatten = arrs => arrs.reduce((acc, item) => acc.concat(item), []) const groupedByName = { abc: [ { name: 'abc', effectiveDate: '2016-01-01T00:00:00+00:00' }, { name: 'abc', effectiveDate: '2016-04-01T00:00:00+00:00' }, { name: 'abc', effectiveDate: '2016-05-01T00:00:00+00:00' } ], abcd: [ { name: 'abcd', effectiveDate: '2016-02-01T00:00:00+00:00' }, { name: 'abcd', effectiveDate: '2016-09-01T00:00:00+00:00' } ] } const ungroupAndFlatten = pipe( ungroup, flatten ) console.log( ungroupAndFlatten(groupedByName) ) 

Function Composition with n Arguments

And again we have

• compose

  \nconst compose = (...fns) => fns.reduceRight((f, g) => (...args) =>  \n    g(f(...args))) \n

• pipe

  \nconst pipe = (...fns) => fns.reduce((f, g) => (...args) =>  \n    g(f(...args))) \n

Our goal is it to compose to ungroup and flatten the function groupBy , too.
We could try

const groupByNameAndFlattenAndUngroup = compose(
    flatten,
    ungroup,
    groupBy('name', x)  // <-- this is our problem
)

but this will not work. We can only compose functions with one argument.. The solution is to rewrite groupBy to a curried version:

const groupBy = xs => key =>
xs.reduce((rv, x) => {
    (rv[x[key]] = rv[x[key]] || []).push(x)
    return rv
}, {})

const groupByNameAndFlattenAndUngroup = (key, xs) => compose(
    flatten,
    ungroup,
    groupBy ('name')
) (xs)

But this solution can be even shorter. If we switch the order of the arguments from groupBy to groupBy = key => xs => {/*..*/} we can do:

const groupBy = key => xs =>
    xs.reduce((rv, x) => {
        (rv[x[key]] = rv[x[key]] || []).push(x)
        return rv
    }, {})

const groupByNameAndFlattenAndUngroup = compose(
    flatten,
    ungroup,
    groupBy ('name')
)

Working Example

 const arrs = [ {name: 'abc', effectiveDate: "2016-01-01T00:00:00+00:00"}, {name: 'abcd', effectiveDate: "2016-02-01T00:00:00+00:00"}, {name: 'abcd', effectiveDate: "2016-09-01T00:00:00+00:00"}, {name: 'abc', effectiveDate: "2016-04-01T00:00:00+00:00"}, {name: 'abc', effectiveDate: "2016-05-01T00:00:00+00:00"}, ] const compose = (...fns) => fns.reduceRight((f, g) => (...args) => g(f(...args))) const ungroup = obj => Object.keys(obj) .map(x => obj[x]); const flatten = arrs => arrs.reduce((acc, item) => acc.concat(item), []) const groupBy = key => xs => xs.reduce((rv, x) => { (rv[x[key]] = rv[x[key]] || []).push(x) return rv }, {}) const groupByName = groupBy ('name') const groupByEffectiveDate = groupBy ('effectiveDate') const groupByNameAndFlattenAndUngroup = compose( flatten, ungroup, groupByName ) const groupBygroupByEffectiveDateAndFlattenAndUngroup = compose( flatten, ungroup, groupByEffectiveDate ) console.log( groupByNameAndFlattenAndUngroup (arrs) ) console.log( groupBygroupByEffectiveDateAndFlattenAndUngroup (arrs) ) 

Answer 3

您可以在单个函数中取消组合和展平。

const ungroupAndFlatten = (obj) => Object.keys(obj).reduce((a, k) => {obj[k].forEach(e => a.push(e)); return a}, [])