Popularity
5.7
Declining
Activity
0.0
Declining
80
3
2

Monthly Downloads: 563
Programming language: Elixir
License: Apache License 2.0
Tags: Macros    

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.

Do you think we are missing an alternative of pipe_to or a related project?

Add another 'Macros' Package

README

Build Status

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

bench_1

Case 2: Pipe with anonymous function vs PipeTo with index

bench_2

Case 3: Pipe with anonymous vs use PipeTo.Override

bench_3

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.


*Note that all licence references and agreements mentioned in the pipe_to README section above are relevant to that project's source code only.