Deprecate <-/2 in favor of send/2

Author: José Valim

CHANGELOG.md

@@ -22,6 +22,7 @@
   * [Kernel] `is_alive/0` is deprecated in favor of `Node.alive?`
   * [Kernel] `Kernel.inspect/2` with `Inspect.Opts[]` is deprecated in favor of `Inspect.Algebra.to_doc/2`
   * [Kernel] `Kernel.inspect/2` with `:raw` option is deprecated, use `:records` option instead
+  * [Kernel] Deprecate `<-/2` in favor of `send/2`
 
 * Backwards incompatible changes
   * [String] Change `String.next_grapheme/1` and `String.next_codepoint/1` to return `nil` on string end

lib/elixir/lib/kernel.ex

@@ -866,6 +866,24 @@ defmodule Kernel do
     :erlang.round(number)
   end
 
+  @doc """
+  Sends a message to the given `dest` and returns the message.
+
+  `dest` may be a remote or local pid, a (local) port, a locally
+  registered name, or a tuple `{registed_name, node}` for a registered
+  name at another node.
+
+  ## Examples
+
+      iex> send self(), :hello
+      :hello
+
+  """
+  @spec send(dest :: pid | port | atom | { atom, node }, msg) :: msg when msg: any
+  def send(dest, msg) do
+    :erlang.send(dest, msg)
+  end
+
   @doc """
   Returns the pid (process identifier) of the calling process.
   Allowed in guard clauses.
@@ -893,7 +911,7 @@ defmodule Kernel do
   ## Examples
 
       current = Kernel.self
-      child   = spawn(fn -> current <- { Kernel.self, 1 + 2 } end)
+      child   = spawn(fn -> send current, { Kernel.self, 1 + 2 } end)
 
       receive do
         { ^child, 3 } -> IO.puts "Received 3 back"
@@ -931,7 +949,7 @@ defmodule Kernel do
   ## Examples
 
       current = Kernel.self
-      child   = spawn_link(fn -> current <- { Kernel.self, 1 + 2 } end)
+      child   = spawn_link(fn -> send current, { Kernel.self, 1 + 2 } end)
 
       receive do
         { ^child, 3 } -> IO.puts "Received 3 back"
@@ -1118,19 +1136,10 @@ defmodule Kernel do
     quote do: __op__(:/, unquote(left), unquote(right))
   end
 
-  @doc """
-  Sends a message to the process identified on the left.
-  A process can be identified by its PID or, if it is registered,
-  by an atom.
-
-  ## Examples
-
-      process = Kernel.self
-      process <- { :ok, "Sending myself a message" }
-
-  """
-  defmacro pid <- msg do
-    quote do: :erlang.!(unquote(pid), unquote(msg))
+  @doc false
+  def pid <- msg do
+    IO.write "<-/2 is deprecated, please use send/2 instead\n#{Exception.format_stacktrace}"
+    :erlang.!(pid, msg)
   end
 
   @doc """
@@ -1773,7 +1782,7 @@ defmodule Kernel do
   end
 
   def inspect(arg, opts) when is_list(opts) do
-    case opts[:raw] do
+    case Keyword.get(opts, :raw) do
       nil ->
         :ok
       raw ->

lib/elixir/lib/kernel/error_handler.ex

@@ -19,7 +19,7 @@ defmodule Kernel.ErrorHandler do
       { :error, _ } ->
         parent = :erlang.get(:elixir_compiler_pid)
         ref    = :erlang.make_ref
-        parent <- { :waiting, self(), ref, module }
+        send parent, { :waiting, self(), ref, module }
         :erlang.garbage_collect(self)
         receive do
           { ^ref, :ready } ->

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -65,7 +65,7 @@ defmodule Kernel.ParallelCompiler do
   # Release waiting processes
   defp spawn_compilers([h|t], original, output, callbacks, waiting, queued, schedulers, result) when is_pid(h) do
     { ^h, ref, _ } = List.keyfind(waiting, h, 0)
-    h <- { ref, :ready }
+    send h, { ref, :ready }
     waiting = List.keydelete(waiting, h, 0)
     spawn_compilers(t, original, output, callbacks, waiting, queued, schedulers, result)
   end
@@ -107,7 +107,7 @@ defmodule Kernel.ParallelCompiler do
   defp spawn_compilers([], original, output, callbacks, waiting, queued, schedulers, result) when length(waiting) == length(queued) do
     Enum.each queued, fn { child, _, _ } ->
       { ^child, ref, _ } = List.keyfind(waiting, child, 0)
-      child <- { ref, :release }
+      send child, { ref, :release }
     end
     wait_for_messages([], original, output, callbacks, waiting, queued, schedulers, result)
   end
@@ -126,7 +126,7 @@ defmodule Kernel.ParallelCompiler do
         end
 
         # Release the module loader which is waiting for an ack
-        child <- { ref, :ack }
+        send child, { ref, :ack }
 
         available  = lc { pid, _, waiting_module } inlist waiting,
                         waiting_module == module,
@@ -138,7 +138,7 @@ defmodule Kernel.ParallelCompiler do
       { :waiting, child, ref, on } ->
         # Oops, we already got this module. Do not put it on waiting.
         if :lists.member(on, result) do
-          child <- { :release, ref }
+          send child, { :release, ref }
         else
           waiting = [{ child, ref, on }|waiting]
         end

lib/elixir/lib/process.ex

@@ -264,8 +264,8 @@ defmodule Process do
 
   @doc """
   Associates the name with a pid or a port identifier. name, which must
-  be an atom, can be used instead of the pid / port identifier in the
-  send operator (name <- message).
+  be an atom, can be used instead of the pid / port identifier with the
+  `Kernel.send/2` function.
 
   See http://www.erlang.org/doc/man/erlang.html#register-2 for more info.
   """

lib/elixir/lib/stream.ex

@@ -340,7 +340,7 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.each([1, 2, 3], fn(x) -> self <- x end)
+      iex> stream = Stream.each([1, 2, 3], fn(x) -> send self, x end)
       iex> Enum.to_list(stream)
       iex> receive do: (x when is_integer(x) -> x)
       1

lib/elixir/src/elixir_dispatch.erl

@@ -375,6 +375,7 @@ in_erlang_functions() ->
     % { now, 0 },
     { round, 1 },
     { self, 0 },
+    { send, 2 },
     { size, 1 },
     { spawn, 1 },
     { spawn, 3 },

lib/elixir/test/elixir/stream_test.exs

@@ -169,18 +169,18 @@ defmodule StreamTest do
     par = self
     pid = spawn_link fn ->
       Enum.each Stream.drop(&inbox_stream/2, -3),
-                fn x -> par <- { :stream, x } end
+                fn x -> send par, { :stream, x } end
     end
 
-    pid <- { :stream, 1 }
-    pid <- { :stream, 2 }
-    pid <- { :stream, 3 }
+    send pid, { :stream, 1 }
+    send pid, { :stream, 2 }
+    send pid, { :stream, 3 }
     refute_receive { :stream, 1 }
 
-    pid <- { :stream, 4 }
+    send pid, { :stream, 4 }
     assert_receive { :stream, 1 }
 
-    pid <- { :stream, 5 }
+    send pid, { :stream, 5 }
     assert_receive { :stream, 2 }
     refute_receive { :stream, 3 }
   end

lib/elixir/test/erlang/control_test.erl

@@ -60,13 +60,13 @@ try_else_test() ->
 % Receive
 
 receive_test() ->
-  {10, _} = eval("self() <- :foo\nreceive do\n:foo -> 10\nend"),
-  {20, _} = eval("self() <- :bar\nreceive do\n:foo -> 10\n_ -> 20\nend"),
+  {10, _} = eval("send self(), :foo\nreceive do\n:foo -> 10\nend"),
+  {20, _} = eval("send self(), :bar\nreceive do\n:foo -> 10\n_ -> 20\nend"),
   {30, _} = eval("receive do\nafter 1 -> 30\nend").
 
 vars_receive_test() ->
-  {10, _} = eval("self() <- :foo\nreceive do\n:foo ->\na = 10\n:bar -> nil\nend\na"),
-  {nil, _} = eval("self() <- :bar\nreceive do\n:foo ->\nb = 10\n_ -> 20\nend\nb"),
+  {10, _} = eval("send self(), :foo\nreceive do\n:foo ->\na = 10\n:bar -> nil\nend\na"),
+  {nil, _} = eval("send self(), :bar\nreceive do\n:foo ->\nb = 10\n_ -> 20\nend\nb"),
   {30, _} = eval("receive do\n:foo -> nil\nafter\n1 -> c = 30\nend\nc"),
   {30, _} = eval("x = 1\nreceive do\n:foo -> nil\nafter\nx -> c = 30\nend\nc").
 

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -292,12 +292,12 @@ defmodule ExUnit.Assertions do
 
   ## Examples
 
-      self <- :hello
+      send self, :hello
       assert_received :hello
 
   You can also match against specific patterns:
 
-      self <- { :hello, "world" }
+      send self, { :hello, "world" }
       assert_received { :hello, _ }
 
   """
@@ -478,7 +478,7 @@ defmodule ExUnit.Assertions do
 
   ## Examples
 
-      self <- :hello
+      send self, :hello
       refute_received :bye
 
   """