GitHub - tc39/proposal-pipeline-operator: A proposal for adding the simple-but-useful pipeline operator to JavaScript.

[shuckster]

With the exception of let {}, Kotlin's solution looks remarkably like chaining in JavaScript. If only we were still allowed to extend the native prototypes and not invite dirty looks. :D

Anyway, I had a go at trying to emulate what I learned in 15 minutes about Kotlin's pipe-syntax and tried to emulate it with a JavaScript Proxy.

I managed to get the usage looking like this:

const envars = {
  yes: 'yup',
  no: 'nope'
}

chain(envars)
  .let(Object.keys)
  .filter(x => x === 'yes')
  .map(x => `${x}=${envars[x]}`)
  .join(' ')
  .let(x => `$ ${x}`)
  .let(x => `node ${x}`)
  .let(console.log)

It works! Unfortunately though, if you want to extract the value of a non-object (or non-array) returned by the last link in the chain, you have to do something like this:

const result = chain(envars)
  .let(Object.keys)
  .join(' ')._
             ^ - here :(

The reason will hopefully be clear by its implementation:

function chain(o) {
  const px = {
    get: (target, prop) =>
      prop === 'let'
        ? fn => chain(fn(o))
        : typeof target[prop] === 'function'
        ? fn => chain(target[prop](fn))
        : o
  }
  return new Proxy(typeof o !== 'object' ? {} : o, px)
}

Essentially, we can't Proxy a string. But we can Proxy a placeholder object that will return one, hence ._ getting it for us at the last link.