# Piping and Function Composition Equivalence

By Xah Lee. Date: . Last updated: .

Had a divine revelation, that is, how pipe operator is equivalent to function composition.

Here's background.

Pipe operator, e.g. in unix `|` or as dot operator in ruby etc, is very useful.

In general, operators can be considered as a function. (in many function languages, operators can be used with function call syntax.)

I want to write a pipe function in my JavaScript library, e.g. `Pipe(x,f,g):=g(f(x))`

But there's also function composition, i.e.

`pipe(x,f,g) == compose(f,g)(x)`

function compose is also quite useful. But, pipe and compose seems very similar. I wish not to have to write both, because it seems redundant.

(Note, between pipe and function composition, pipe is far more useful.)

## The Problem

So, the problem is, is there a way to consider pipe and function composition as equivalent , so that you can implement just one function in a programing language library, and it can be practically use for both piping and compose?

Note: pipe, is mathematically the same as nested function call.

Thought for 1 hour, and found an answer that's mathematically sane!

## Solution

the math sane answer is, just write a function composition function. Allow each argument to be a non-function e.g. 3. When a non-function argument is encountered, treat it as constant function, i.e. 3 is a function that always returns 3. This way, `pipe(x,f,g)` is same as `compose(g,f,x)` .

So, when `x` is a non-function value such as 3, the whole `compose(g,f,x)` also returns a non-function value.

Note, this works fine in languages that's not strictly typed. `compose(g,f,x)` return a function or a value, depending on whether `x` is a function or a value.

But in strictly typed languages, you may not have a return value whose type depends on input parameters. But such languages have ways to resolve that. e.g. a type defined to be or.