Use mapper when converting list to table reader (#13)

Author: jonatanklosko

lib/table/mapper.ex

@@ -6,46 +6,52 @@ defmodule Table.Mapper do
   # This enumerable proxies traversal to the underlying enumerable,
   # so it keeps the same properties, such as optimized slicing.
 
-  defstruct [:enumerable, :mapper]
+  defstruct [:enumerable, :fun]
 
   @doc """
   Returns an enumerable that will apply the given function on
   enumeration.
   """
   @spec map(Enumerable.t(), (any() -> any())) :: Enumerable.t()
+  def map(enumerable, fun)
+
+  def map(%__MODULE__{} = mapper, fun) do
+    %{mapper | fun: &fun.(mapper.fun.(&1))}
+  end
+
   def map(enumerable, fun) do
-    %__MODULE__{enumerable: enumerable, mapper: fun}
+    %__MODULE__{enumerable: enumerable, fun: fun}
   end
 
   defimpl Enumerable do
-    def count(proxy) do
-      Enumerable.count(proxy.enumerable)
+    def count(mapper) do
+      Enumerable.count(mapper.enumerable)
     end
 
     # The mapping is not necessarily reversible, so we fall
     # back to a linear search. For enumerables representing
     # data entries member? would generally be linear anyway
-    def member?(_proxy, _element), do: {:error, __MODULE__}
+    def member?(_mapper, _element), do: {:error, __MODULE__}
 
-    def reduce(proxy, acc, fun) do
-      Enumerable.reduce(proxy.enumerable, acc, fn original, acc ->
-        fun.(proxy.mapper.(original), acc)
+    def reduce(mapper, acc, fun) do
+      Enumerable.reduce(mapper.enumerable, acc, fn original, acc ->
+        fun.(mapper.fun.(original), acc)
       end)
     end
 
-    def slice(proxy) do
-      case Enumerable.slice(proxy.enumerable) do
+    def slice(mapper) do
+      case Enumerable.slice(mapper.enumerable) do
         {:ok, size, fun} ->
           fun =
             case fun do
               to_list_fun when is_function(to_list_fun, 1) ->
-                &(to_list_fun.(&1) |> Enum.map(proxy.mapper))
+                &(to_list_fun.(&1) |> Enum.map(mapper.fun))
 
               slicing_fun when is_function(slicing_fun, 2) ->
-                &(slicing_fun.(&1, &2) |> Enum.map(proxy.mapper))
+                &(slicing_fun.(&1, &2) |> Enum.map(mapper.fun))
 
               slicing_fun when is_function(slicing_fun, 3) ->
-                &(slicing_fun.(&1, &2, &3) |> Enum.map(proxy.mapper))
+                &(slicing_fun.(&1, &2, &3) |> Enum.map(mapper.fun))
             end
 
           {:ok, size, fun}

lib/table/reader/enumerable.ex

@@ -37,7 +37,7 @@ defmodule Table.Reader.Enumerable do
         case columns_for(head) do
           {:ok, columns} ->
             meta = %{columns: columns}
-            enum = Stream.map(enum, &record_values(&1, columns))
+            enum = Table.Mapper.map(enum, &record_values(&1, columns))
             {:rows, meta, enum}
 
           :error ->

test/mapper_test.exs

@@ -21,4 +21,15 @@ defmodule Table.MapperTest do
     assert Enum.member?(enumerable, 36) == true
     assert Enum.member?(enumerable, 37) == false
   end
+
+  test "mapping multiple times retains a flat mapper" do
+    enumerable =
+      1..3
+      |> Mapper.map(fn x -> x * x end)
+      |> Mapper.map(fn x -> x + 1 end)
+
+    assert %Mapper{enumerable: 1..3} = enumerable
+
+    assert Enum.to_list(enumerable) == [2, 5, 10]
+  end
 end