# Piping and Function Composition Equivalence

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

Here is 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.

#haskell #ocaml #clojure

treating data (such as number) as (constant) function is a powerful idea. Because it lets you treat function and data in a uniform way.