Also in Haskell [0]:

    (|>) :: Seq a -> a -> Seq a
    O(1). Add an element to the right end of a sequence. Mnemonic: a triangle with the single element at the pointy end. 

It seems to be in the containers package since 2005: [1]

[0]: http://hackage.haskell.org/package/containers-0.5.5.1/docs/D...

[1]: https://github.com/haskell/containers/commit/1e61853dbd4b9fc...

Which has a totally different meaning from the F# usage.

'|>' from F# is the same as 'flip $' in haskell, or (&) imported from the lens library

In Elixir, |> does not flip arguments. It lets you chain together multiple functions by inserting the result of the previous function as the first argument of the following function. Here's an example from http://www.theerlangelist.com/2014/01/why-elixir.html

The following code computes the sum of squares of all positive numbers of a list:

list |> Enum.filter(&(&1 > 0)) |> Enum.map(&(&1 * &1)) |> Enum.reduce(0, &(&1 + &2))

F# doesn't flip arguments either. It's an operator:

    let (|>) x f = f x

Is basically saying:

    x |> f  is equal to  f x

So in F# it's the same as Elixir, but the value x is applied to the function f (passed as the last argument). i.e.

    list |> List.filter (fun x -> x > 0)
         |> List.map (fun x -> x * x)
         |> List.reduce (fun s x -> s + x)

I was going off what platz said in another comment, that |> flips the arguments to |> in the same way Haskells flip function does, which I thought the type signature of the the F# |> also indicated. I'm sorry if I'm misunderstanding things.

I think the difference though is that the |> in Elixir is actually a macro that modifies the following function call's first argument.

So list |> Enum.filter(&(&1 > 0)) doesn't end up using filter as a curried function as one would find in Haskell:

Enum.filter(&(&1 > 0)) list

The end result is actually:

Enum.filter(list, &(&1 > 0))