pipe_to alternatives and similar packages
Based on the "Macros" category.
Alternatively, view pipe_to alternatives based on common mentions on social networks and blogs.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
rulex
This tiny library (2 macros only) allows you to define very simple rule handler using Elixir pattern matching. -
-
-
-
TypedStructor
TypedStructor is a library for defining typed structs, exceptions and record macros with effortlessly. -
apix
Simple convention and DSL for transformation of elixir functions to an API for later documentation and or validation. -
Bang
Bang simply adds dynamic bang! functions to your existing module functions with after-callback. -
-
-
-
InfluxDB – Built for High-Performance Time Series Workloads
Do you think we are missing an alternative of pipe_to or a related project?
README
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 PipeToin 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?
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.
*Note that all licence references and agreements mentioned in the pipe_to README section above
are relevant to that project's source code only.