Skip to content
This repository has been archived by the owner on Jun 6, 2023. It is now read-only.
/ pipe_to Public archive

The enhanced elixir pipe operator which can specify the target position

License

Notifications You must be signed in to change notification settings

taiansu/pipe_to

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

36 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Build Status

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

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.

About

The enhanced elixir pipe operator which can specify the target position

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages