taiansu / pipe_to

The enhanced elixir pipe operator which can specify the target position

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.