Defining backticks using "pipe" operations

(Thanks to Simon Fowler and others on the Links team for the discussion leading to this...)

In Haskell, you can use a 2-argument function as if it were an infix operator by putting "backticks" around it like this:

ghci> let plus x y = x + y
ghci> 1 `plus` 2
3

In a number of functional languages such as F# and OCaml, the following "pipe" operations have become popular (I'll continue using Haskell syntax, though):

ghci> let (|>) x f = f x
ghci> let (<|) f x = f x
ghci> [1,2,3] |> map (plus 1)
[2,3,4]



With the above definitions, the "backtick" behavior is definable:

ghci> 1 |>plus<| 2
3

What's going on here: the above code is parsed as

(1 |> plus) <| 2

So first, we evaluate (1 |> plus), which is defined as (plus 1), i.e. a partial application of plus.  So we have

(plus 1) <| 2

Then this is defined as (plus 1) 2, i.e. now plus is fully applied and we can evaluate it as 1+2 = 3.

Warning: This relies in a somewhat hacky way on the default left-associativity of infix operators in Haskell. You get different results if you explicitly parenthesize like this

1 |> (plus <| 2)

(or if |> and <| were defined as right-associative), at least if the underlying operation is noncommutative.