Disclaimer

Start from Elixir 1.12.0, we have Kernel.then/2, which let us pipe into a partial application, nativately. We should follow the official convention while we could. For example:

1
|> then(&Enum.at([1, 2, 3], &1))

5
|> then(&Enum.take(1..10, &1))
|> Enum.reverse()

I'll maintain this library for legacy Elixir versions, until they reach their end of lifes.

Thanks for all the starts. Let's move on, live long and prosper.

PipeTo

The enhanced pipe operator which can specify the target position.

Installation

To use PipeTo with your projects, edit your mix.exs file and add it as a dependency:

def deps do
  [{:pipe_to, "~> 0.2"}]
end

Then run mix deps.get

Quick start

• import PipeTo in your module,
• pipe with ~>
• use _ to specify the target position of left-hand side expression.

> import PipeTo
> 1 ~> Enum.at([1, 2, 3], _)
# 2

It works with pipe operator nicely.

> 5 ~> Enum.take(1..10, _) |> Enum.reverse()
# [5, 4, 3, 2, 1]

In fact, if you don't specify the position with _, it acts just like normal |>

> [4, 8, 1] ~> Enum.max()
# 8

Override the Kernel.|>/2

Since ~> is the enhanced pipe operator, you can override the Kernel.|>/2 with it.

defmodule Foo do
  use PipeTo.Override

  def bar do
    2 |> Enum.drop(1..10, _) |> Enum.at(1)
  end
end

Foo.bar
# 4

Performance

use PipeTo sightly faster then normal pipe in all these cases below. For the case 2 and case 3, I will guess that anonymous function slow down the oridinary pipe. But it doesn't explain why in the case 1 PipeTo insignificantly faster then ordinary pipe. Any ideas?

Case 1: Ordinary Pipe vs PipeTo without index

Case 2: Pipe with anonymous function vs PipeTo with index

Case 3: Pipe with anonymous vs use PipeTo.Override

Disclaimer

I have read through the proposals of pipe operator enhancement on the elixir-lang-core, like this, this or this.

The reason I still want this is because the combination of curried function (or partial application) with pipe operator is so elegant, like this F# example here. Since Elixir doesn't have these mechnism, and also anonymous function call use .(), so syntactically (well, aesthetically) the only choice I have is to modify the pipe operator.

Is it any good?

Yes

License

Apache 2

TODO

• Discard the default operator, user should specify the operator expicitly, to work with lib like Witchcraft better.
• Pipe into mutiple target at once
• Pipe into target in nested expression, instead of only the shallowest level like now.