Add Process.send/2 and Process.send_after/3

Author: José Valim

CHANGELOG.md

@@ -1,12 +1,15 @@
 # v0.12.3-dev
 
 * Enhancements
+  * [Kernel] Explicit functions inlined by the compiler, including operators. This means that `Kernel.+/2` will now expand to `:erlang.+/2` and so on
   * [Mix] Do not fail if a Mix dependency relies on an outdated Elixir version
+  * [Process] Add `Process.send/2` and `Process.send_after/3`
   * [Version] Add `Version.compare/2`
 
 * Bug fixes
   * [Atom] Inspect `:...` and `:foo@bar` without quoting
   * [Kernel] Guarantee nullary funs/macros are allowed in guards
+  * [Process] Ensure monitoring functions are inlined by the compiler
 
 * Deprecations
   * [Kernel] `binary_to_term/1`, `binary_to_term/2`, `term_to_binary/1` and `term_to_binary/2` are deprecated in favor of their counterparts in the `:erlang` module

lib/elixir/lib/process.ex

@@ -111,14 +111,37 @@ defmodule Process do
   end
 
   @doc """
-  Returns the pid of a new process started by the application of `fun`.
-  It behaves exactly the same as `Kernel.spawn/1`.
+  Sends a message to the given process.
 
-  Inlined by the compiler.
+  It does the same as `Kernel.send/2`.
   """
-  @spec spawn((() -> any)) :: pid
-  def spawn(fun) do
-    :erlang.spawn(fun)
+  @spec send(dest, msg) :: msg when
+        dest: pid | port | atom | { atom, node },
+        msg: any
+  def send(dest, msg) do
+    :erlang.send(dest, msg)
+  end
+
+  @doc """
+  Sends `msg` to `dest` after `time` millisecons.
+
+  If `dest` is a pid, it has to be a pid of a local process, dead or alive.
+  If `dest` is an atom, it is supposed to be the name of a registered process
+  which is looked up at the time of delivery. No error is given if the name does
+  not refer to a process.
+
+  This function returns a timer reference, which can be read or canceled with
+  `:erlang.read_timer/1`, `:erlang.start_timer/3` and `:erlang.cancel_timer/1`.
+  Note `time` cannot be greater than `4294967295`.
+
+  Finally, the timer will be automatically canceled if the given `dest` is a pid
+  which is not alive or when the given pid exits. Note that timers will not be
+  automatically canceled when `dest` is an atom (as the atom resolution is done
+  on delivery).
+  """
+  @spec send_after(pid | atom, term, non_neg_integer) :: reference
+  def send_after(dest, msg, time) do
+    :erlang.send_after(time, dest, msg)
   end
 
   @type spawn_opt  :: :link | :monitor | {:priority, :low | :normal | :high} |
@@ -127,6 +150,17 @@ defmodule Process do
                       {:min_bin_vheap_size, non_neg_integer}
   @type spawn_opts :: [spawn_opt]
 
+  @doc """
+  Returns the pid of a new process started by the application of `fun`.
+  It behaves exactly the same as `Kernel.spawn/1`.
+
+  Inlined by the compiler.
+  """
+  @spec spawn((() -> any)) :: pid
+  def spawn(fun) do
+    :erlang.spawn(fun)
+  end
+
   @doc """
   Returns the pid of a new process started by the application of `fun`.