What purpose does the backward pipe serve in F#? (Q262)

http://stackoverflow.com/a/5444278/11635 

I find it useful on those occasions when you have a chain of pipes, but for one of them you want to pass the data in as the FIRST param, rather than the last.

Here's an example:

// setup some functions
let replace (oldS:string) newS (a:string) = 
    a.Replace(oldS,newS)
let add a b = 
    sprintf "%s %s" a b
let toUpper (a:string) = 
    a.ToUpper()

// pipe "hello" through the functions
"hello" 
|> replace "h" "j"
|> add "world"  // "world is first param
|> toUpper

//result "WORLD JELLO" // not what we want

// pipe "hello" through the functions
"hello" 
|> replace "h" "j"
|> add  toUpper

//result "JELLO WORLD" // correct! 

(again, with better formatting!)

// setup some functions
let replace (oldS:string) newS (a:string) = a.Replace(oldS,newS)
let add a b = sprintf "%s %s" a b
let toUpper (a:string) = a.ToUpper()

// pipe "hello" through the functions
"hello" 
|> replace "h" "j"
|> add "world"  // "world is first param
|> toUpper

//result "WORLD JELLO" // not what we want

// pipe "hello" through the functions
"hello" 
|> replace "h" "j"
|> add  toUpper

//result "JELLO WORLD" // correct! 

The formatting is being stripped out!
The missing line in the second example should be:

(left pipe) add (right pipe) "world" 

Here's the code in a gist 
https://gist.github.com/swlaschin/8111200 

Yes backwards pipe is mostly used to avoid the closing paranthese. It's a bit like $ in haskell (explained here: http://learnyouahaskell.com/higher-order-functions#function-application)

Basically the reason is that one wants to lower the precendence of the function application operator.

When you type: 
printfn "%A" 1 + 2 

The F# compiler places the paranthesis like this due to precendence and left associativity of function application operator (http://msdn.microsoft.com/en-us/library/dd233228.aspx): 
(((printfn "%A") 1) + 2)

This won't compile which is why you have to either use parantheses or  (printfn "%A") (1 + 2)
printfn "%A"  (printfn "%A") <| (1 + 2)

The benefit of <| is mostly seen when the right-side expression spans several lines.


<| in F# isn't quite as good as $ in haskell though because . $ in haskell has the lowest precedence and is right associative which for this particular reason is what you want. Example of when <| fails us:
printfn "%A"  List.filter (fun x -> x%2 = 0)

(the problem is that  have the same precendence and associativity which makes the F# compiler place the parantheses "wrongly")

PS. The definition of backward pipe: let inline (  ) x f = f x
PS. Had to switch to Chrome to post here. Just FYI. 

I notice the WP in it's wisdom are sometimes removing <| which breaks some of the code-samples. 

Another place when <| shines is that F# warns when you call a function that returns a value you don't handle:
x.DoStuff ()

F# then asks you to either act on the value or ignore it:
ignore (x.DoStuff ())

I just prefer
ignore <| x.DoStuff ()

PS. This is something I wished for along time for C# so IMHO this warning is a good one 

The primary purpose of the operators |> and  for the "backward" variant, though I will use your naming style here, with |> being forward and  g |> h instead. This is nice since it also behaves better with newlines. You can line up the |> operators underneath each other and get a clearer view of what happens. Especially if g, say, is a composition of several other small functions.

In functional programming, it is common to have many small functions which are then composed to form the program. We need some tools to glue functions into compositions and this is where the >>, |> and  is glue for puzzle pieces that allows you to put them together in different ways.

The story of <| is almost the same. In code which is composition-heavy, you often have to read the code from right-to-left rather than left to right. In h(g(f(x))) the application of the inner function, f, happens first. Then g and finally h. So functional programmers often compose code in a right-to-left style. The backwards pipe is a bit more readable in this style: h <| g <| f x. And it follows the natural direction of the function call application.

<|| and <||| are just different variants for working with 2- and 3-tuples respectively. The pieces must fit together so things are type-correct. Hence their existence.

So the reason is mostly for giving the programmer different options for expressing their code to a reader. It is nice to be able to throw in either  to delimit other groups of code and make it easier to read. 

Oops, my less-thans got eaten by the blog software and made the description meaningless. Here is the full text:

https://gist.github.com/jlouis/8111923/raw/a453f1bd9efb054459142621e707949afeecbce3/gistfile1.txt 

WRT to <|| and <||| I think the purpose of those is slightly different.

If you have a F# function taking two arguments and the values you have are in a tuple <|| can help.

You can do this:
let x,y = myTuple
let s = sum x y

or this:
let s = sum (fst myTuple) (sndmyTuple)

But with <|| you do this:
let s = sum <|| myTuple 

The operator <| in F# obviously corresponds to the operator $ in Haskell. That's defined by f $ x = f x, which by itself seems quite meaningless. But the associativity and precedence is set so that f $ g $ h $ x = f (g (h x)) and $ can thus be used to reduce the numbers of parenthesis. 

Yes, it looks like those threading macros @Bodil were talking about at Oredev. In the right pipe you put stuff as first arg, and with left pipe as last arg.