In F# what does the >> operator mean?

Question

I noticed in some code in this sample that contained the >> operator:

let printTree =
  tree >> Seq.iter (Seq.fold (+) \"\" >> printfn \"%s\")


        

Answer 1

The >> operator composes two functions, so x |> (g >> f) = x |> g |> f = f (g x). There's also another operator << which composes in the other direction, so that (f << g) x = f (g x), which may be more natural in some cases.

Answer 2

That is function composition, used for partial application

Answer 3

According to F# Symbol and Operator Reference it is Forward Function Composition operator.

Answer 4

The composition operators, << and >> are use to join two functions such that the result of one becomes the input of the other. Since functions are also values, unless otherwise note, they are treated as such so that the following expressions are equivalent:

f1 f2 f3 ... fn x = (..((f1 f2) f3) ... fn) x

Specifically, f2, f3, ...fn and x are treated as values and are not evaluated prior to being passed as parameters to their preceding functions. Sometimes that is what you want but other times you want to indicate that the result of one function is to be the input of the other. This can be realized using the composition operators << and >> thus:

(f1 << f2 << f3 ... << fn) x = f1(f2(f3 ... (fn x )..)

Similarly

(fn >> ... f3 >> f2 >> f1) x = f1(f2(f3 ... (fn x )..)

Since the composition operator returns a function, the explicit parameter, x, is not required unlike in the pipe operators x |> fn ... |> f1 or f1 <| ... fn <| x

Answer 5

It's the function composition operator.

More info on Chris Smith's blogpost.

Introducing the Function Composition operator (>>):

let inline (>>) f g x = g(f x)

Which reads as: given two functions, f and g, and a value, x, compute the result of f of x and pass that result to g. The interesting thing here is that you can curry the (>>) function and only pass in parameters f and g, the result is a function which takes a single parameter and produces the result g ( f ( x ) ).

Here's a quick example of composing a function out of smaller ones:

let negate x = x * -1 
let square x = x * x 
let print  x = printfn "The number is: %d" x
let square_negate_then_print = square >> negate >> print 
asserdo square_negate_then_print 2

When executed prints ‘-4’.