Add insert_elem/3 and delete_elem/2 functions, deprecate setelem

in favour of set_elem

For Erlang versions prior to R16B, emulate corresponding BIFs

Author: yrashk

lib/elixir/lib/file.ex

@@ -271,7 +271,7 @@ defmodule File do
   path. Returns `:ok` or `{ :error, reason }`.
   """
   def write_stat(path, File.Stat[] = stat, opts // []) do
-    F.write_file_info(path, setelem(stat, 0, :file_info), opts)
+    F.write_file_info(path, set_elem(stat, 0, :file_info), opts)
   end
 
   @doc """

lib/elixir/lib/hash_dict.ex

@@ -399,29 +399,29 @@ defmodule HashDict do
   defp node_put(node, 0, hash, key, value) do
     pos = bucket_index(hash)
     { new, count } = bucket_put(elem(node, pos), key, value)
-    { setelem(node, pos, new), count }
+    { set_elem(node, pos, new), count }
   end
 
   defp node_put(node, depth, hash, key, value) do
     pos = bucket_index(hash)
     { new, count } = node_put(elem(node, pos), depth - 1, bucket_next(hash), key, value)
-    { setelem(node, pos, new), count }
+    { set_elem(node, pos, new), count }
   end
 
   # Deletes a key from the bucket
   defp node_delete(node, 0, hash, key) do
     pos = bucket_index(hash)
     case bucket_delete(elem(node, pos), key) do
       { _, 0 }    -> { node, 0 }
-      { new, -1 } -> { setelem(node, pos, new), -1 }
+      { new, -1 } -> { set_elem(node, pos, new), -1 }
     end
   end
 
   defp node_delete(node, depth, hash, key) do
     pos = bucket_index(hash)
     case node_delete(elem(node, pos), depth - 1, bucket_next(hash), key) do
       { _, 0 }    -> { node, 0 }
-      { new, -1 } -> { setelem(node, pos, new), -1 }
+      { new, -1 } -> { set_elem(node, pos, new), -1 }
     end
   end
 
@@ -477,7 +477,7 @@ defmodule HashDict do
   defp node_relocate(node // unquote(node_escaped), bucket, n) do
     :lists.foldl fn { key, value }, acc ->
       pos = key |> bucket_hash() |> bucket_nth_index(n)
-      setelem(acc, pos, bucket_put!(elem(acc, pos), key, value))
+      set_elem(acc, pos, bucket_put!(elem(acc, pos), key, value))
     end, node, bucket
   end
 end

lib/elixir/lib/kernel.ex

@@ -1926,26 +1926,114 @@ defmodule Kernel do
   end
 
   @doc """
-  Define setelem to set Tuple element according to Elixir conventions
+  Define set_elem to set Tuple element according to Elixir conventions
   (i.e. it expects the tuple as first argument, zero-index based).
 
-  It is implemented as a macro so it can be used in guards.
-
   ## Example
 
       iex> tuple = { :foo, :bar, 3 }
-      ...> setelem(tuple, 0, :baz)
+      ...> set_elem(tuple, 0, :baz)
       { :baz, :bar, 3 }
 
   """
-  defmacro setelem(tuple, index, value) when is_integer(index) do
+  defmacro set_elem(tuple, index, value) when is_integer(index) do
     quote do: :erlang.setelement(unquote(index + 1), unquote(tuple), unquote(value))
   end
 
+  defmacro set_elem(tuple, index, value) do
+    quote do: :erlang.setelement(unquote(index) + 1, unquote(tuple), unquote(value))
+  end
+
+  @doc false
   defmacro setelem(tuple, index, value) do
+    IO.puts "setelem is deprecated, please use set_elem instead\n#{Exception.format_stacktrace(__CALLER__.stacktrace)}"
     quote do: :erlang.setelement(unquote(index) + 1, unquote(tuple), unquote(value))
   end
 
+  @doc """
+  Define insert_elem to insert element into a tuple according to
+  Elixir conventions (i.e. it expects the tuple as first argument,
+  zero-index based).
+
+  Please note that in versions of Erlang prior to R16B there is no BIF
+  for this operation and it is emulated by converting the tuple to a list
+  and back and is, therefore, inefficient.
+
+  ## Example
+
+      iex> tuple = { :bar, :baz }
+      ...> insert_elem(tuple, 0, :foo)
+      { :foo, :bar, :baz }
+  """
+  defmacro insert_elem(tuple, index, value) when is_integer(index) do
+    case :proplists.get_value(:insert_element,
+                              :proplists.get_value(:exports, :erlang.module_info,[])) do
+      3 ->
+        quote do: :erlang.insert_element(unquote(index + 1), unquote(tuple), unquote(value))
+      :undefined ->
+        do_insert_elem(tuple, index, value)
+    end
+  end
+  defmacro insert_elem(tuple, index, value) do
+    case :proplists.get_value(:insert_element,
+                              :proplists.get_value(:exports, :erlang.module_info,[])) do
+      3 ->
+        quote do: :erlang.insert_element(unquote(index) + 1, unquote(tuple), unquote(value))
+      :undefined ->
+        do_insert_elem(tuple, index, value)
+    end
+  end
+
+  defp do_insert_elem(tuple, index, value) do
+    quote do
+      {h, t} = :lists.split(unquote(index),
+                            tuple_to_list(unquote(tuple)))
+      list_to_tuple(h ++ [unquote(value)|t])
+    end
+  end
+
+  @doc """
+  Define delete_elem to delete element from a tuple according to
+  Elixir conventions (i.e. it expects the tuple as first argument,
+  zero-index based).
+
+  Please note that in versions of Erlang prior to R16B there is no BIF
+  for this operation and it is emulated by converting the tuple to a list
+  and back and is, therefore, inefficient.
+
+  ## Example
+
+      iex> tuple = { :foo, :bar, :baz }
+      ...> delete_elem(tuple, 0)
+      { :bar, :baz }
+  """
+  defmacro delete_elem(tuple, index) when is_integer(index) do
+    case :proplists.get_value(:delete_element,
+                              :proplists.get_value(:exports, :erlang.module_info,[])) do
+      2 ->
+        quote do: :erlang.delete_element(unquote(index + 1), unquote(tuple))
+      :undefined ->
+        do_delete_elem(tuple, index)
+    end
+  end
+  defmacro delete_elem(tuple, index) do
+    case :proplists.get_value(:delete_element,
+                              :proplists.get_value(:exports, :erlang.module_info,[])) do
+      2 ->
+        quote do: :erlang.delete_element(unquote(index) + 1, unquote(tuple))
+      :undefined ->
+        do_delete_elem(tuple, index)
+    end
+  end
+
+  defp do_delete_elem(tuple, index) do
+    quote do
+      {h, [_|t]} = :lists.split(unquote(index),
+                                tuple_to_list(unquote(tuple)))
+      list_to_tuple(h ++ t)
+    end
+  end
+
   @doc """
   Provides an integer division macro according to Erlang semantics.
   Raises an error if one of the arguments is not an integer.

lib/elixir/lib/record.ex

@@ -445,19 +445,19 @@ defmodule Record do
   #     end
   #
   #     def :atime.(value, record) do
-  #       setelem(record, 1, value)
+  #       set_elem(record, 1, value)
   #     end
   #
   #     def :mtime.(record) do
-  #       setelem(record, 2, value)
+  #       set_elem(record, 2, value)
   #     end
   #
   #     def :atime.(callback, record) do
-  #       setelem(record, 1, callback.(elem(record, 1)))
+  #       set_elem(record, 1, callback.(elem(record, 1)))
   #     end
   #
   #     def :mtime.(callback, record) do
-  #       setelem(record, 2, callback.(elem(record, 2)))
+  #       set_elem(record, 2, callback.(elem(record, 2)))
   #     end
   #
   defp accessors([{ :__exception__, _ }|t], 1) do

lib/elixir/test/elixir/tuple_test.exs

@@ -8,7 +8,15 @@ defmodule TupleTest do
   end
 
   test :setelem do
-    assert setelem({ :a, :b, :c }, 1, :d) == { :a, :d, :c }
+    assert set_elem({ :a, :b, :c }, 1, :d) == { :a, :d, :c }
+  end
+
+  test :insert_elem do
+    assert insert_elem({ :bar, :baz }, 0, :foo) == { :foo, :bar, :baz }
+  end
+
+  test :delete_elem do
+    assert delete_elem({ :foo, :bar, :baz }, 0) == { :bar, :baz }
   end
 
   test :optional_comma do