 
   ## join
 
-  # The first item is simply stringified unless ...
+  defp do_join([h|t], joiner, nil) do
+    do_join(t, joiner, to_binary(h))
+  end
+
+  defp do_join([h|t], joiner, acc) do
+    acc = << acc | :binary, joiner | :binary, to_binary(h) | :binary >>
+    do_join(t, joiner, acc)
+  end
+
+  defp do_join([], _joiner, acc) do
+    acc || ""
+  end
+
   defp do_join({ h, next }, iterator, joiner, nil) do
     do_join(iterator.(next), iterator, joiner, to_binary(h))
   end
 
-  # The first item is :stop, then we return an empty string;
-  defp do_join(:stop, _, _joiner, nil) do
-    ""
-  end
-
-  # All other items are concatenated to acc, by first adding the joiner;
   defp do_join({ h, next }, iterator, joiner, acc) do
     acc = << acc | :binary, joiner | :binary, to_binary(h) | :binary >>
     do_join(iterator.(next), iterator, joiner, acc)
   end
 
-  # Until we have to stop iteration, then we return acc.
   defp do_join(:stop, _, _joiner, acc) do
-    acc
+    acc || ""
   end
 
   ## map join
 
-  # The first item is simply stringified unless ...
+  defp do_map_join([h|t], mapper, joiner, nil) do
+    do_map_join(t, mapper, joiner, to_binary(mapper.(h)))
+  end
+
+  defp do_map_join([h|t], mapper, joiner, acc) do
+    acc = << acc | :binary, joiner | :binary, to_binary(mapper.(h)) | :binary >>
+    do_map_join(t, mapper, joiner, acc)
+  end
+
+  defp do_map_join([], _mapper, _joiner, acc) do
+    acc || ""
+  end
+
   defp do_map_join({ h, next }, iterator, mapper, joiner, nil) do
     do_map_join(iterator.(next), iterator, mapper, joiner, to_binary(mapper.(h)))
   end
 
-  # The first item is :stop, then we return an empty string;
-  defp do_map_join(:stop, _, _mapper, _joiner, nil) do
-    ""
-  end
-
-  # All other items are concatenated to acc, by first adding the joiner;
   defp do_map_join({ h, next }, iterator, mapper, joiner, acc) do
     acc = << acc | :binary, joiner | :binary, to_binary(mapper.(h)) | :binary >>
     do_map_join(iterator.(next), iterator, mapper, joiner, acc)
   end
 
-  # Until we have to stop iteration, then we return acc.
   defp do_map_join(:stop, _, _mapper, _joiner, acc) do
-    acc
+    acc || ""
   end
 
   ## map


  ## split_with

  defp do_split_with({ h, next }, iterator, fun, acc, module) do
    case fun.(h) do
      x in [false, nil] ->

      #=> { [2], [1,3] }

  """
  def partition(collection, fun) when is_list(collection) do
    do_partition(collection, fun, [], [])
  end

  def partition(collection, fun) do
    case I.iterator(collection) do
      { iterator, pointer } ->
        do_partition(pointer, iterator, fun, [], [])
      list when is_list(list) ->
        partition(list, fun)
    end
  end

  @doc """
