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.
The enhanced pipe operator which can specify the target position.
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
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
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
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?
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.
Apache 2
- 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.