Added additional syntax to make cleaner use of tap

Author: mgwidmann

README.md

@@ -41,18 +41,19 @@ defmodule Foo do
     input
       |> Enum.map(&(to_string(&1)))
       |> Foo.HardWorker.work
-      |> tap({:ok, r1}, r1)
+      |> tap({:ok, r1} ~> r1) # tap({:ok, r1}, r1) is also a supported format
       |> Enum.map(&(Foo.IntermediateResult.handle(&1)))
-      |> tap({:ok, r2}, r2)
+      |> tap({:ok, r2} ~> r2) # tap({:ok, r2}, r2) is also a supported format
   end
 end
 ```
 
 And the second example
 
 ```elixir
+# tap({:ok, result}, result) also supported
 def my_function do
-  something |> something_else |> tap({:ok, result}, result)
+  something |> something_else |> tap({:ok, result} ~> result)
 end
 ```
 
@@ -63,14 +64,14 @@ end
 Take the following example:
 
 ```elixir
-my_data = {:data1, :data2} |> tap({d1, d2}, d1)
+my_data = {:data1, :data2} |> tap({d1, d2} ~> d1)
 d2 # => ** (CompileError) ...: function d2/0 undefined
 ```
 
 Instead you can use `destruct` to destructure the data you want. This does the same thing but with the side effect of keeping the binding you created in your patterns.
 
 ```elixir
-{:data1, :data2} |> destruct({d1, d2}, d1) |> some_func(d2)
+{:data1, :data2} |> destruct({d1, d2} ~> d1) |> some_func(d2)
 ```
 
 ### Unmatched results
@@ -80,7 +81,7 @@ Instead you can use `destruct` to destructure the data you want. This does the s
 Because `tap/3` uses `case` you will get a `CaseClauseError` with the data which did not match in the error report.
 
 ```elixir
-{:error, "reason"} |> tap({:ok, result}, result)
+{:error, "reason"} |> tap({:ok, result} ~> result)
 # ** (CaseClauseError) no case clause matching: {:error, "reason"}
 ```
 
@@ -90,6 +91,6 @@ Because `tap/3` uses `case` you will get a `CaseClauseError` with the data which
 Since `destruct/3` uses `=` you will instead get a `MatchError` with the data which did not match in the error report.
 
 ```elixir
-{:error, "reason"} |> destruct({:ok, result}, result)
+{:error, "reason"} |> destruct({:ok, result} ~> result)
 # ** (MatchError) no match of right hand side value: {:error, "reason"}
 ```

lib/pattern_tap.ex

@@ -14,11 +14,23 @@ defmodule PatternTap do
     end
   end
 
+  defmacro tap(data, {:~>, _, [pattern, var]}) do
+    quote do
+      tap(unquote(data), unquote(pattern), unquote(var))
+    end
+  end
+
   defmacro destruct(data, pattern, var) do
     quote do
       unquote(pattern) = unquote(data)
       unquote(var)
     end
   end
 
+  defmacro destruct(data, {:~>, _, [pattern, var]}) do
+    quote do
+      destruct(unquote(data), unquote(pattern), unquote(var))
+    end
+  end
+
 end

mix.exs

@@ -3,7 +3,7 @@ defmodule PatternTap.Mixfile do
 
   def project do
     [app: :pattern_tap,
-     version: "0.2.0",
+     version: "0.2.1",
      elixir: "~> 1.0",
      description: """
      Macro for tapping into a pattern match while using the pipe operator

test/pattern_tap_test.exs

@@ -4,52 +4,73 @@ defmodule PatternTapTest do
 
   test "can do simple pattern matching" do
     assert tap(:ok, :ok, nil) == nil
+    assert tap(:ok, :ok ~> nil) == nil
     assert destruct(:ok, :ok, nil) == nil
+    assert destruct(:ok, :ok ~> nil) == nil
   end
 
   test "can do list pattern matching" do
     assert tap([:a], [a], a) == :a
+    assert tap([:a], [a] ~> a) == :a
     assert destruct([:a], [a], a) == :a
+    assert destruct([:a], [a] ~> a) == :a
   end
 
   test "variables are not available after" do
     tap([:foo], [f], f)
     assert binding[:f] == nil
+    tap([:foo], [f] ~> f)
+    assert binding[:f] == nil
   end
 
   test "can do tuple pattern matching" do
     assert tap({:b}, {b}, b) == :b
+    assert tap({:b}, {b} ~> b) == :b
     assert destruct({:b}, {b}, b) == :b
+    assert destruct({:b}, {b} ~> 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"
+    assert @data |> Enum.map(&(to_string(&1))) |> tap([_, b, _] ~> b) == "b"
     assert @data |> Enum.map(&(to_string(&1))) |> destruct([_, b, _], b) == "b"
+    assert @data |> Enum.map(&(to_string(&1))) |> destruct([_, b, _] ~> b) == "b"
   end
 
   @data [key: :val, key2: :val2]
   test "can match |> with keyword lists" do
     assert @data |> tap([_, {:key2, v}], v) == :val2
+    assert @data |> tap([_, {:key2, v}] ~> v) == :val2
     assert @data |> destruct([_, {:key2, v}], v) == :val2
+    assert @data |> destruct([_, {:key2, v}] ~> v) == :val2
   end
 
   test "can match typical {:ok, result}" do
     assert {:ok, 1} |> tap({:ok, result}, result) == 1
+    assert {:ok, 1} |> tap({:ok, result} ~> result) == 1
     assert {:ok, 1} |> destruct({:ok, result}, result) == 1
+    assert {:ok, 1} |> destruct({:ok, result} ~> result) == 1
   end
 
   test "failure matches result in the correct error message" do
     assert_raise CaseClauseError, "no case clause matching: {:error, \"reason\"}", fn ->
       {:error, "reason"} |> tap({:ok, result}, result)
     end
+    assert_raise CaseClauseError, "no case clause matching: {:error, \"reason\"}", fn ->
+      {:error, "reason"} |> tap({:ok, result} ~> result)
+    end
     assert_raise MatchError, "no match of right hand side value: {:error, \"reason\"}", fn ->
       {:error, "reason"} |> destruct({:ok, result}, result)
     end
+    assert_raise MatchError, "no match of right hand side value: {:error, \"reason\"}", fn ->
+      {:error, "reason"} |> destruct({:ok, result} ~> result)
+    end
   end
 
   test "destruct keeps variables around" do
     destruct({:a, :b}, {a, b}, a)
+    destruct({:a, :b}, {a, b} ~> a)
     assert a == :a
     assert b == :b
   end