Deprecate functions as collectable

Author: José Valim

CHANGELOG.md

@@ -28,6 +28,7 @@
   * [URI] `to_string/1` now properly converts URI to strings when the schema is missing
 
 * Deprecations
+  * [Collectable] Having a function as collectable is deprecated
   * [Module] `Module.function/3` is deprecated, please use `:erlang.make_fun/3` instead
 
 * Backwards incompatible changes

lib/elixir/lib/collectable.ex

@@ -98,6 +98,7 @@ defimpl Collectable, for: Function do
   end
 
   def into(function) do
+    IO.write :stderr, "warning: passing a function as Collectable is deprecated\n#{Exception.format_stacktrace}"
     {function, function}
   end
 end

lib/elixir/test/elixir/enum_test.exs

@@ -189,11 +189,6 @@ defmodule EnumTest.List do
     assert Enum.into([a: 1, b: 2], %{c: 3}) == %{a: 1, b: 2, c: 3}
     assert Enum.into(%{a: 1, b: 2}, []) == [a: 1, b: 2]
     assert Enum.into([1, 2, 3], "numbers: ", &to_string/1) == "numbers: 123"
-    assert Enum.into([1, 2, 3], fn
-      func, {:cont, x} when is_function(func) -> [x]
-      list, {:cont, x} -> [x|list]
-      list, _ -> list
-    end) == [3, 2, 1]
   end
 
   test :intersperse do

lib/elixir/test/elixir/kernel/comprehension_test.exs

@@ -6,6 +6,25 @@ defmodule Kernel.ComprehensionTest do
   import ExUnit.CaptureIO
   require Integer
 
+  defmodule PDict do
+    defstruct []
+
+    defimpl Collectable do
+      def empty(struct) do
+        struct
+      end
+
+      def into(struct) do
+        {struct,
+         fn
+           _, {:cont, x} -> Process.put(:into_cont, [x|Process.get(:into_cont)])
+           _, :done -> Process.put(:into_done, true)
+           _, :halt -> Process.put(:into_halt, true)
+         end}
+      end
+    end
+  end
+
   defp to_bin(x) do
     << x >>
   end
@@ -86,7 +105,7 @@ defmodule Kernel.ComprehensionTest do
     Process.put(:into_done, false)
     Process.put(:into_halt, false)
 
-    for x <- 1..3, into: collectable_pdict do
+    for x <- 1..3, into: %PDict{} do
       x * 2
     end
 
@@ -101,7 +120,7 @@ defmodule Kernel.ComprehensionTest do
     Process.put(:into_halt, false)
 
     catch_error(
-      for x <- 1..3, into: collectable_pdict do
+      for x <- 1..3, into: %PDict{} do
         if x > 2, do: raise("oops"), else: x
       end
     )
@@ -114,21 +133,13 @@ defmodule Kernel.ComprehensionTest do
   test "for comprehension with into, generators and filters" do
     Process.put(:into_cont, [])
 
-    for x <- 1..3, Integer.odd?(x), << y <- "hello" >>, into: collectable_pdict do
+    for x <- 1..3, Integer.odd?(x), << y <- "hello" >>, into: %PDict{} do
       x + y
     end
 
     assert IO.iodata_to_binary(Process.get(:into_cont)) == "roohkpmmfi"
   end
 
-  defp collectable_pdict do
-    fn
-      _, {:cont, x} -> Process.put(:into_cont, [x|Process.get(:into_cont)])
-      _, :done -> Process.put(:into_done, true)
-      _, :halt -> Process.put(:into_halt, true)
-    end
-  end
-
   ## List generators (inlined by the compiler)
 
   test "list for comprehensions" do

lib/elixir/test/elixir/stream_test.exs

@@ -3,6 +3,25 @@ Code.require_file "test_helper.exs", __DIR__
 defmodule StreamTest do
   use ExUnit.Case, async: true
 
+  defmodule PDict do
+    defstruct []
+
+    defimpl Collectable do
+      def empty(struct) do
+        struct
+      end
+
+      def into(struct) do
+        {struct,
+         fn
+           _, {:cont, x} -> Process.put(:stream_cont, [x|Process.get(:stream_cont)])
+           _, :done -> Process.put(:stream_done, true)
+           _, :halt -> Process.put(:stream_halt, true)
+         end}
+      end
+    end
+  end
+
   test "streams as enumerables" do
     stream = Stream.map([1,2,3], &(&1 * 2))
 
@@ -297,15 +316,15 @@ defmodule StreamTest do
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %PDict{})
 
     assert is_lazy(stream)
     assert Stream.run(stream) == :ok
     assert Process.get(:stream_cont) == [3,2,1]
     assert Process.get(:stream_done)
     refute Process.get(:stream_halt)
 
-    stream = Stream.into(fn _, _ -> raise "error" end, collectable_pdict)
+    stream = Stream.into(fn _, _ -> raise "error" end, %PDict{})
     catch_error(Stream.run(stream))
     assert Process.get(:stream_halt)
   end
@@ -315,7 +334,7 @@ defmodule StreamTest do
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict, fn x -> x*2 end)
+    stream = Stream.into([1, 2, 3], %PDict{}, fn x -> x*2 end)
 
     assert is_lazy(stream)
     assert Enum.to_list(stream) == [1, 2, 3]
@@ -329,7 +348,7 @@ defmodule StreamTest do
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %PDict{})
 
     assert is_lazy(stream)
     assert Enum.take(stream, 1) == [1]
@@ -561,7 +580,7 @@ defmodule StreamTest do
   end
 
   test "zip/2 closes on inner error" do
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %PDict{})
     stream = Stream.zip(stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end))
 
     Process.put(:stream_done, false)
@@ -570,7 +589,7 @@ defmodule StreamTest do
   end
 
   test "zip/2 closes on outer error" do
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %PDict{})
              |> Stream.zip([:a, :b, :c])
              |> Stream.map(fn _ -> throw(:error) end)
 
@@ -592,14 +611,6 @@ defmodule StreamTest do
     match?(%Stream{}, stream) or is_function(stream, 2)
   end
 
-  defp collectable_pdict do
-    fn
-      _, {:cont, x} -> Process.put(:stream_cont, [x|Process.get(:stream_cont)])
-      _, :done -> Process.put(:stream_done, true)
-      _, :halt -> Process.put(:stream_halt, true)
-    end
-  end
-
   defp inbox_stream({:suspend, acc}, f) do
     {:suspended, acc, &inbox_stream(&1, f)}
   end