Pass result of functional chain to function

Question

If I have an array someArray that I first want to do some operations on and then pass that result to a function arrfun that takes an array as an argument. Like the following

let arr = someArray.filter(foo).map(bar)
let result = arrfun(arr)

In the above scenario I would like to avoid having to assign an intermediary variable to be passed to arrfun. I would like to have something like this.

Object.prototype.pipe = function(f) {return f(this)}

let result = someArray.filter(foo).map(bar).pipe(arrfun)

• In lieu of a .pipe() how would you solve this?
• Would it be sensible to introduce that function to Object?
• Is pipe the best name for such a function? chain? pass?

New example

const pc = options => options
  .join(' ')
  .match(/--[\w.]* [\w.]*/g)
  .map(s => s.slice(2).split(' '))
  .map(([key, value]) => ({key, value}))
  .map(nestObject)
  .reduce((acc, val) => Object.assign(acc, val), {})

const nestObject = ({key, value}) => key
  .split('.')
  .reverse()
  .reduce((inner, key) => ({[key]: inner}), value)

In the above example a problem is that .match returns null if no match is found. Using .pipe you could solve it ny changing that line to

.pipe(s => s.match(/--[\w.]* [\w.]*/g) || [])

How would you solve this one without pipe?

Answer 1

In the above scenario I would like to avoid having to assign an intermediary variable to be passed to arrfun.

Are you overlooking this simple, straightforward expression ?

let result = arrfun(someArray.filter(foo).map(bar))

---

right-to-left function composition

Or maybe you wish for classic (right-to-left) function composition?

const compose = (f,...fs) => x =>
  f === undefined ? x : f(compose(...fs)(x))

const filter = f => xs =>
  xs.filter(x => f(x))

const map = f => xs =>
  xs.map(x => f(x))

const foo = x =>
  x > 3
  
const bar = x =>
  x * x
  
const arrfun = xs =>
  xs.reverse()

const myfunc =
  compose(arrfun, map(bar), filter(foo))

let someArray = [1,2,3,4,5,6]

let result = myfunc(someArray)

console.log(result)
// [ 36, 25, 16 ]

---

left-to-right function composition

The same answer as above using left-to-right function composition

const compose = (f,...fs) => x =>
  f === undefined ? x : compose(...fs)(f(x))

const filter = f => xs =>
  xs.filter(x => f(x))

const map = f => xs =>
  xs.map(x => f(x))

const foo = x =>
  x > 3
  
const bar = x =>
  x * x
  
const arrfun = xs =>
  xs.reverse()

// notice order of functions
const myfunc =
  compose(filter(foo), map(bar), arrfun)
  
let someArray = [1,2,3,4,5,6]

let result = myfunc(someArray)

console.log(result)
// [ 36, 25, 16 ]

---

Identity functor

I dont think wrapping the entire thing scales in terms of readability. Imagine that you have to chain some more stuff to arrfun and then wrap that thing in yet another function.

You should see this answer I wrote about the Identity functor - This gives you a chainable interface but doesn't touch native prototypes

const Identity = x => ({
  runIdentity: x,
  map: f => Identity(f(x))
})

const foo = x =>
  x > 3
  
const bar = x =>
  x * x
  
const arrfun = xs =>
  xs.reverse()

const myfunc = xs =>
  Identity(xs)
    .map(xs => xs.filter(foo))
    .map(xs => xs.map(bar))
    .map(xs => arrfun(xs))
    .runIdentity

let someArray = [1,2,3,4,5,6]

let result = myfunc(someArray)

console.log(result)
// [ 35, 25, 16 ]

Of course if you keep filter and map as we defined before, it cleans up the definition of myfunc

const Identity = x => ({
  runIdentity: x,
  map: f => Identity(f(x))
})

const filter = f => xs =>
  xs.filter(x => f(x))

const map = f => xs =>
  xs.map(x => f(x))

const foo = x =>
  x > 3
  
const bar = x =>
  x * x
  
const arrfun = xs =>
  xs.reverse()

const myfunc = x =>
  Identity(x)
    .map(filter(foo))
    .map(map(bar))
    .map(arrfun)
    .runIdentity

let someArray = [1,2,3,4,5,6]

let result = myfunc(someArray)

console.log(result)
// [ 35, 25, 16 ]

And don't get hung up on foo and bar being defined up front. We can use lambda expressions directly within myfunc if you wanted to

const myfunc = xs =>
  Identity(xs)
    .map(xs => xs.filter(x => x > 3))
    .map(xs => xs.map(x => x * x))
    .map(arrfun)
    // or skip defining arrfun somewhere else and just ...
    // .map(xs => xs.reverse())
    .runIdentity

Answer 2

You could compose your manipulator function and your result function first as reusable functions. Like:

let arr = [1,2,3,4,5];
const manipulatorFn = arr => arr.map(item => item +1);
const arrFunc = (arr, fn) => fn(arr);

or if you want to do some more stuff in the arrFunc

const arrFunc = (arr, fn) => {
  let a = fn(arr);

  // do some more stuff with a
  return a;
};

now you can fetch your result

let result = arrFunc(arr, manipulatorFn);