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