Function position poses from right to left:

const p  = f => g => x => f(g(x));
const inc = x => x + 1;
const dec = x => x - 1;
const sqr = x => x * x;
let seq = p(dec)(p(sqr)(inc));

seq(2); // 8

seq(2) is transformed to dec(sqr(inc(2))) and the application order is inc(2)...sqr...dec. Thus the functions are invoked in the reverse order in which they are passed to p. This isn't intuitive for Javascript programmers, since they're used to method chaining, which goes from left to right:

o = {
  x: 2,
  inc() { return this.x + 1, this },
  dec() { return this.x - 1, this },
  sqr() { return this.x * this.x, this }
}

o.dec().sqr().inc(); // 2

I consider that confusing. Here's a reversed position:

const flipped = f => g => x => g(f(x));
let seql = flipped(dec)(flipped(sqr)(inc));

seql(2); // 2

Are there any reasons why function position goes from right to left?

Function position poses from right to left:

const p  = f => g => x => f(g(x));
const inc = x => x + 1;
const dec = x => x - 1;
const sqr = x => x * x;
let seq = p(dec)(p(sqr)(inc));

seq(2); // 8

seq(2) is transformed to dec(sqr(inc(2))) and the application order is inc(2)...sqr...dec. Thus the functions are invoked in the reverse order in which they are passed to p. This isn't intuitive for Javascript programmers, since they're used to method chaining, which goes from left to right:

o = {
  x: 2,
  inc() { return this.x + 1, this },
  dec() { return this.x - 1, this },
  sqr() { return this.x * this.x, this }
}

o.dec().sqr().inc(); // 2

I consider that confusing. Here's a reversed position:

const flipped = f => g => x => g(f(x));
let seql = flipped(dec)(flipped(sqr)(inc));

seql(2); // 2

Are there any reasons why function position goes from right to left?

• javascript
• functional-programming
• position
• associative
• function-position

• 1 "Thus the functions are evaluated in the reverse order of their application" - huh, what? – Bergi Commented Jun 9, 2016 at 14:19
• You seem to be asking why arguments (right) are evaluated before the function call (left), no? – Bergi Commented Jun 9, 2016 at 14:21
• Would it make more sense to you if seq was written p(p(dec)(sqr))(inc)? (function position is mutative) – Bergi Commented Jun 9, 2016 at 14:25
• @Bergi I rephrased the sentence in question – user6445533 Commented Jun 9, 2016 at 14:26
• @Bergi hm, that wouldn't change the fact, that p is evaluated from right to left. I haven't any problems with it, I just ask why? – user6445533 Commented Jun 9, 2016 at 14:30

2 Answers 2

To answer the original question: Why does function position pose from right to left?

1. So it is traditionally made in mathematics
2. p(f)(g)(x) has the same order as f(g(x))
3. It is trivial to create a reversed or forward position (see example)

Forward function position:

const p = f => g => x => f(g(x));
const flip = f => x => y => f(y)(x);
const flipped = flip(p);

const inc = a => a + 1;
const sqr = b => b * b;

   p(sqr)(inc)(2); // 9, since 2 is first put into inc then sqr
flipped(sqr)(inc)(2); // 5, since 2 is first put into sqr then inc

This way of calling functions is called currying, and works like this:

// the original:
p(sqr)(inc)(2); // 9

// is interpreted by JS as:
( ( ( p(sqr) ) (inc) ) (2) ); // 9 still (yes, this actually executes!)

// it is even clearer when we separate it into discrete steps:
const pSqr = p(sqr); // g => x => sqr(g(x))
pSqr(inc)(2);   // 9 still
const pSqrInc = pSqr(inc); // x => sqr(x + 1)
pSqrInc(2);     // 9 still
const pSqrInc2 = pSqrInc(2); // sqr(3)
pSqrInc2;       // 9 still

So functions are posed and interpreted (by the JS interpreter) left to right, while on execution, their values flow through each function from right to left. In short: first outside-in, then inside-out.

But flip has the restriction that a flipped position can't be bined with itself to form a "higher order position":

const p2 = p(p)(p);
const flipped2 = flipped(flipped)(flipped);
const add = x => y => x + y;

   p2(sqr)(add)(2)(3); // 25
flipped2(sqr)(add)(2)(3); // "x => f(g(x))3" which is nonsense

Conclusion: The right-to-left order is traditional/conventional but not intuitive.

Your question is actually about the order of arguments in a definition of the function position operator rather than right- or left-associativity. In mathematics, we usually write "f o g" (equivalent to p(f)(g) in your definition) to mean the function that takes x and returns f(g(x)). Thus "f o (g o h)" and "(f o g) o h" are equivalent and both mean the function that maps each argument x to f(g(h(x))).

That said, we sometimes write f;g (equivalent to pl(f)(g) in your code) to mean the function which maps x to g(f(x)). Thus, both (f;g);h and f;(g;h) mean the function mapping x to h(g(f(x))).

A reference: https://en.wikipedia/wiki/Function_position#Alternative_notations