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.
-
typed_struct
An Elixir library for defining structs with a type without writing boilerplate code. -
shorter_maps
Elixir ~M sigil for map shorthand. `~M{id, name} ~> %{id: id, name: name}` -
ok_jose
Pipe elixir functions that match ok/error tuples or custom patterns. -
crudry
Elixir library for DRYing CRUD in Phoenix Contexts and Absinthe Resolvers. -
pattern_tap
Macro for tapping into a pattern match while using the pipe operator -
rulex
This tiny library (2 macros only) allows you to define very simple rule handler using Elixir pattern matching. -
guardsafe
Macros expanding into code that can be safely used in guard clauses. -
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. -
backports
Ensure backwards compatibility even if newer functions are used
ONLYOFFICE Docs — document collaboration in your environment
Do you think we are missing an alternative of pipe_to or a related project?
Popular Comparisons
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 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?
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.