Initial push

Author: mgwidmann

.gitignore

@@ -0,0 +1,4 @@
+/_build
+/deps
+erl_crash.dump
+*.ez

README.md

@@ -0,0 +1,64 @@
+PatternTap
+==========
+
+##### The pipe operator `|>` is an awesome feature of Elixir.
+
+But when your result cannot be directly input into the next function, you have to stop, pattern match out the value you want and start piping again!
+
+It is a common pattern to return data like `{:ok, result}` or `{:error, reason}`. When you want to handle both cases, theres not much you can do except use another function or a `case`. But otherwise you can `use PatternTap`!
+
+#### Not fun way
+
+```elixir
+defmodule Foo do
+  def get_stuff(input) do
+    {:ok, intermediate_result} = input
+      |> Enum.map(&(to_string(&1)))
+      |> Foo.HardWorker.work
+    {:ok, result} = intermediate_result
+      |> Enum.map(&(Foo.IntermediateResult.handle(&1)))
+    result
+  end
+end
+```
+
+Anytime where the object you want requires pattern matching but you want to either return on one line or continue piping, you can `use PatternTap`!
+
+```elixir
+{:ok, result} = something |> something_else
+result
+```
+
+#### Pattern Tap
+
+Heres the above example using `PatternTap`
+
+```elixir
+defmodule Foo do
+  def get_stuff(input) do
+    input
+      |> Enum.map(&(to_string(&1)))
+      |> Foo.HardWorker.work
+      |> tap(:r1, {:ok, r1})
+      |> Enum.map(&(Foo.IntermediateResult.handle(&1)))
+      |> tap(:r2, {:ok, r2})
+  end
+end
+```
+
+And the second example
+
+```elixir
+something |> something_else |> tap(:result, {:ok, result})
+```
+
+### Usage
+
+The `tap/3` macro takes `data, return_variable, pattern` for its three parameters. This takes advantage of Elixir's `binding` call. The variables you create in your pattern will be available even after the tap call. Take this use case for example.
+
+```elixir
+[:a] |> tap(:a, [a])  # => Returns :a
+IO.puts "#{a}"        # The variable a is available
+```
+
+The symbol `:a` passed into `tap` is what variable to return. All other variables will be available after the `tap` call, though `tap` will only return a single variable. This means `tap({:ok, 1}, :r, {e, r})` will return `r` (which has the value 1) but in the next statement, the variable `e` will be available (which has the value `:ok`).

config/config.exs

@@ -0,0 +1,24 @@
+# This file is responsible for configuring your application
+# and its dependencies with the aid of the Mix.Config module.
+use Mix.Config
+
+# This configuration is loaded before any dependency and is restricted
+# to this project. If another project depends on this project, this
+# file won't be loaded nor affect the parent project. For this reason,
+# if you want to provide default values for your application for third-
+# party users, it should be done in your mix.exs file.
+
+# Sample configuration:
+#
+#     config :logger, :console,
+#       level: :info,
+#       format: "$date $time [$level] $metadata$message\n",
+#       metadata: [:user_id]
+
+# It is also possible to import configuration files, relative to this
+# directory. For example, you can emulate configuration per environment
+# by uncommenting the line below and defining dev.exs, test.exs and such.
+# Configuration from the imported file will override the ones defined
+# here (which is why it is important to import them last).
+#
+#     import_config "#{Mix.env}.exs"

lib/pattern_tap.ex

@@ -0,0 +1,16 @@
+defmodule PatternTap do
+
+  defmacro __using__(_) do
+    quote do
+      import PatternTap
+    end
+  end
+
+  defmacro tap(data, var, pattern) do
+    quote do
+      unquote(pattern) = unquote(data)
+      binding[unquote(var)]
+    end
+  end
+
+end

mix.exs

@@ -0,0 +1,30 @@
+defmodule PatternTap.Mixfile do
+  use Mix.Project
+
+  def project do
+    [app: :pattern_tap,
+     version: "0.1.0",
+     elixir: "~> 1.0",
+     deps: deps]
+  end
+
+  # Configuration for the OTP application
+  #
+  # Type `mix help compile.app` for more information
+  def application do
+    [applications: [:logger]]
+  end
+
+  # Dependencies can be Hex packages:
+  #
+  #   {:mydep, "~> 0.3.0"}
+  #
+  # Or git/path repositories:
+  #
+  #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
+  #
+  # Type `mix help deps` for more examples and options
+  defp deps do
+    []
+  end
+end

test/pattern_tap_test.exs

@@ -0,0 +1,33 @@
+defmodule PatternTapTest do
+  use ExUnit.Case
+  use PatternTap
+
+  test "can do simple pattern matching" do
+    assert tap(:ok, nil, :ok) == nil
+  end
+
+  test "can do list pattern matching" do
+    assert tap([:a], :a, [a]) == :a
+    assert a == :a
+  end
+
+  test "can do tuple pattern matching" do
+    assert tap({:b}, :b, {b}) == :b
+    assert b == :b
+  end
+
+  @data [:a, :b, :c]
+  test "can match with the |> operator" do
+    assert @data |> Enum.map(&(to_string(&1))) |> tap(:b, [_, b, _]) == "b"
+  end
+
+  @data [key: :val, key2: :val2]
+  test "can match |> with keyword lists" do
+    assert @data |> tap(:v, [_, {:key2, v}]) == :val2
+  end
+
+  test "can match typical {:ok, result}" do
+    assert {:ok, 1} |> tap(:result, {:ok, result}) == 1
+  end
+  
+end

test/test_helper.exs

@@ -0,0 +1 @@
+ExUnit.start()