Reversed the arguments and removed the use of binding so that atoms are no longer necessary

Author: mgwidmann

README.md

@@ -49,16 +49,16 @@ end
 And the second example
 
 ```elixir
-something |> something_else |> tap(:result, {:ok, result})
+something |> something_else |> tap({:ok, result}, 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.
+The `tap/3` macro takes `data, pattern, return_variable` for its three parameters. 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
+[: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`).
+All other variables will be available after the `tap` call, though `tap` will only return a single variable. This means `tap({:ok, 1}, {e, r}, 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`).

lib/pattern_tap.ex

@@ -6,10 +6,10 @@ defmodule PatternTap do
     end
   end
 
-  defmacro tap(data, var, pattern) do
+  defmacro tap(data, pattern, var) do
     quote do
       unquote(pattern) = unquote(data)
-      binding[unquote(var)]
+      unquote(var)
     end
   end
 

mix.exs

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

test/pattern_tap_test.exs

@@ -3,31 +3,31 @@ defmodule PatternTapTest do
   use PatternTap
 
   test "can do simple pattern matching" do
-    assert tap(:ok, nil, :ok) == nil
+    assert tap(: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 a == :a
   end
 
   test "can do tuple pattern matching" do
-    assert tap({:b}, :b, {b}) == :b
+    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"
+    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
+    assert @data |> tap([_, {:key2, v}], v) == :val2
   end
 
   test "can match typical {:ok, result}" do
-    assert {:ok, 1} |> tap(:result, {:ok, result}) == 1
+    assert {:ok, 1} |> tap({:ok, result}, result) == 1
   end
-  
+
 end