         :ok
     end
 
-    {original, fun}
+    {bitstring, fun}
   end
 end
 
 defimpl Collectable, for: Map do
-  def into(original) do
+  def into(map) do
     fun = fn
-      map, {:cont, {k, v}} -> Map.put(map, k, v)
-      map, :done -> map
-      _, :halt -> :ok
+      map_acc, {:cont, {key, value}} ->
+        Map.put(map_acc, key, value)
+
+      map_acc, :done ->
+        map_acc
+
+      _, :halt ->
+        :ok
     end
 
-    {original, fun}
+    {map, fun}
   end
 end

      #MapSet<[1, 2, 3]>

  To show how the protocol can be implemented, we can again look at the
  implementation for `MapSet`. In this implementation "collecting" elements
  simply means inserting them in the set through `MapSet.put/2`.

      defimpl Collectable, for: MapSet do
        def into(original) do
          collector_fun = fn
            set, {:cont, elem} -> MapSet.put(set, elem)
            set, :done -> set
            _set, :halt -> :ok
          end

          {original, collector_fun}
        end
      end

  """


        :ok
    end

    {[binary], fun}
  end

  def into(bitstring) when is_bitstring(bitstring) do
    fun = fn
      acc, {:cont, x} when is_bitstring(x) ->
        <<acc::bitstring, x::bitstring>>
