Uncomment features related to unquote fragments

Author: José Valim

CHANGELOG.md

@@ -8,16 +8,15 @@
   * [Kernel] Improve meta-programming by allowing `unquote` on `def/2`, `defp/2`, `defmacro/2` and `defmacrop/2`
   * [Kernel] Add support to R16B new functions: `insert_elem/3` and `delete_elem/2`
   * [Kernel] Import conflicts are now lazily handled. If two modules import the same functions, it will fail only if the function is invoked
-  * [Macro] Add `Macro.escape_quoted` to escape quoted expressions
   * [Mix] Support `--cover` on mix test and `test_coverage` on Mixfiles
   * [Record] Each record now provides `Record.options` with the options supported by its `new` and `update` functions
 
 * bug fix
   * [Binary] inspect no longer escapes standalone hash `#`
-  * [IEx] The h helper can now retrieve docs for special forms
+  * [IEx] The `h` helper can now retrieve docs for special forms
   * [Kernel] Record optimizations were not being triggered in functions inside the record module
   * [Kernel] Aliases defined inside macros should be carried over
-  * [Kernel] Fix a bug where nested records could not use the Match[] syntax
+  * [Kernel] Fix a bug where nested records could not use the Record[] syntax
   * [Path] Fix a bug on `Path.expand` when expanding paths starting with `~`
 
 * deprecations

lib/elixir/lib/kernel.ex

@@ -1254,47 +1254,6 @@ defmodule Kernel do
   In the example above, we defined a function `sum` that receives
   two arguments and sum them.
 
-  ## Dynamic generation with atoms
-
-  Elixir follows the same rule as Erlang when it comes to
-  function invocations. Calling a function is the same thing
-  as "invoking at atom". That said, we could invoke a function
-  named sum in these two equivalent ways:
-
-      sum(1, 2)
-      :sum.(1, 2)
-
-  We can also use the atom format to define functions:
-
-      defmodule Foo do
-        def :sum.(a, b) do
-          a + b
-        end
-      end
-
-  In general, a developer never needs to use the format above
-  except when he wants to dynamically define functions with macros.
-  In such scenarios, the name needs to be given dynamically via
-  the unquoting mechanism.
-
-  Imagine a macro that receives keywords and defines a function
-  for each entry in the keyword, using the key as function name
-  and the value as the value returned by the function:
-
-      defmacro defkv(keywords) do
-        Enum.map keywords, fn {k,v} ->
-          quote do
-            def unquote(k)() do
-              unquote(v)
-            end
-          end
-        end
-      end
-
-  This macro could be invoked as:
-
-      defkv one: 1, two: 2
-
   """
   defmacro def(name, do: contents)
 

lib/elixir/lib/macro.ex

@@ -42,7 +42,6 @@ defmodule Macro do
 
       extract_args(quote do: foo)        == { :foo, [] }
       extract_args(quote do: foo())      == { :foo, [] }
-      extract_args(quote do: :foo.())    == { :foo, [] }
       extract_args(quote do: foo(1,2,3)) == { :foo, [1,2,3] }
       extract_args(quote do: 1.(1,2,3))  == :error
 
@@ -53,13 +52,7 @@ defmodule Macro do
 
   @doc """
   Recursively escapes a value so it can be inserted
-  into a syntax tree. This must be used when you have
-  a value that does not represent an AST and you want
-  to introduce it inside a quoted expression.
-
-  If you have a AST and you want to introduce it inside
-  a quoted expression in a escaped form, use Macro.escape_quoted
-  instead.
+  into a syntax tree.
 
   ## Examples
 
@@ -139,17 +132,7 @@ defmodule Macro do
   defp do_splice_join(left, []),    do: left
   defp do_splice_join(left, right), do: { :++, [], [left, right] }
 
-  @doc """
-  Recursively escapes a AST so it can be inserted into
-  another tree unmodified. If the given AST has any
-  call to unquote, they are properly evaluated.
-
-  ## Examples
-
-      iex> Macro.escape_quoted({ :+, [], [1,2] })
-      {:"{}",[],[:+,[],[1,2]]}
-
-  """
+  @doc false
   def escape_quoted(expr) do
     do_escape(expr, true)
   end

lib/elixir/src/elixir.erl

@@ -37,7 +37,7 @@ main(Args) ->
   application:start(?MODULE),
   'Elixir.Kernel.CLI':main(Args).
 
-% Boot and process given options. Invoked by Elixir's script.
+%% Boot and process given options. Invoked by Elixir's script.
 
 start_cli() ->
   application:start(?MODULE),