babel-plugin-transform-function-composition

Transpiles function-bind call expressions to partially applied call expressions. Uses the invocation context to set the first parameter of the callee function.

• Coming from Clojure? This transpiler enables a syntactic suger for thread-first

BIG WARNING: This is a proof-of-concept. See Motivation.

• Example transpilation
• Motivation
• Difference from This-Binding Syntax proposal
  • Benefits
  • Conflicting syntax
• Usage examples
  • Using existing functional programming utilities
  • Using utility functions to construct Promises

Example transpilation

Input:

apple
  ::foo('foo parameter 0', 'foo parameter 1')
  ::bar('bar parameter 0');

Output:

bar('bar parameter 0', foo('foo parameter 0', 'foo parameter 1', apple));

Motivation

Add a syntactic sugar that enables chaining of curried functions. In a functional pipeline, participating functions expect the input of the function to be the last parameter.

In effect, babel-plugin-transform-function-composition is equivalent to using R.pipe in Ramda.

Difference from This-Binding Syntax proposal

ECMAScript This-Binding Syntax proposal introduces a new operator :: which performs this binding and method extraction, i.e.

The following input:

foo::bar()::baz()

Becomes the following output:

var _context;

(_context = (_context = foo, bar).call(_context), baz).call(_context);

babel-plugin-transform-function-composition uses the `::`` operator to create a partially applied function such that the left hand side of the operator is set as the the first parameter to the target function on the right hand side, i.e.

The following input:

foo::bar()::baz()

Becomes the following output:

baz(bar(foo));

Benefits

TODO

Conflicting syntax

At the time of this writing, ECMAScript This-Binding Syntax remains in stage 0.

See What's keeping this from Stage 1?.

Proposal

TODO

Usage examples

Using existing functional programming utilities

import {
  assocPath
} from 'ramda';

({
  name: 'babel-plugin-transform-function-composition'
})
  ::assocPath(['repository', 'type'], 'git')
  ::assocPath(['repository', 'url'], 'https://github.com/gajus/babel-plugin-transform-function-composition');

// {
//   name: 'babel-plugin-transform-function-composition',
//   repository: {
//     type: 'git',
//     url: 'https://github.com/gajus/babel-plugin-transform-function-composition'
//   }
// }

Using utility functions to construct Promises

const map = (callback, promise) => {
  return promise
    .then((values) => {
      return values.map(callback);
    });
};

Promise
  .resolve([
    'foo',
    'bar',
    'baz'
  ])
  ::map((currentValue, index) => {
    return index + ':' + currentValue;
  })
  .then((values) => {
    values;

    // [
    //   '0:foo',
    //   '1:bar',
    //   '2:baz'
    // ]
  });