Start v0.9.0.dev work

Author: José Valim

CHANGELOG.md

@@ -1,3 +1,14 @@
+# v0.9.0.dev
+
+* enhancements
+
+* bug fix
+
+* deprecations
+
+* backwards incompatible changes
+  * [Kernel] Erlang R15 is no longer supported
+
 # v0.8.3 (2013-05-22)
 
 * enhancements

README.md

@@ -14,9 +14,9 @@ If you want to contribute to Elixir or run it from source, clone this repository
 
 If tests pass, you are ready to move on to the [Getting Started guide][1] or to try Interactive Elixir by running: `bin/iex` in your terminal.
 
-However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang R15B or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follow:
+However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang R16B or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follow:
 
-    Erlang R15B (erts-5.8.4) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]
+    Erlang R16B (erts-5.10.1) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]
 
 If you have the correct version and tests still fail, feel free to [open an issue][2].
 

lib/elixir/lib/binary/chars.ex

@@ -74,20 +74,11 @@ defimpl Binary.Chars, for: Number do
     integer_to_binary(thing)
   end
 
-  to_binary = :proplists.get_value(:float_to_binary,
-                :proplists.get_value(:exports, :erlang.module_info, []))
-
-  if to_binary == 2 do
-    def to_binary(thing) when thing > @limit do
-      float_to_binary(thing, scientific: @digits)
-    end
-
-    def to_binary(thing) do
-      float_to_binary(thing, compact: true, decimals: @digits)
-    end
-  else
-    def to_binary(thing) do
-      float_to_binary(thing)
-    end
+  def to_binary(thing) when thing > @limit do
+    float_to_binary(thing, scientific: @digits)
+  end
+
+  def to_binary(thing) do
+    float_to_binary(thing, compact: true, decimals: @digits)
   end
 end

lib/elixir/lib/binary/inspect.ex

@@ -391,21 +391,12 @@ defimpl Binary.Inspect, for: Number do
     integer_to_binary(thing)
   end
 
-  to_binary = :proplists.get_value(:float_to_binary,
-                :proplists.get_value(:exports, :erlang.module_info, []))
-
-  if to_binary == 2 do
-    def inspect(thing, _) when thing > @limit do
-      float_to_binary(thing, scientific: @digits)
-    end
+  def inspect(thing, _) when thing > @limit do
+    float_to_binary(thing, scientific: @digits)
+  end
 
-    def inspect(thing, _) do
-      float_to_binary(thing, compact: true, decimals: @digits)
-    end
-  else
-    def inspect(thing, _) do
-      float_to_binary(thing)
-    end
+  def inspect(thing, _) do
+    float_to_binary(thing, compact: true, decimals: @digits)
   end
 end
 

lib/elixir/lib/io/ansi.ex

@@ -24,9 +24,6 @@ defmodule IO.ANSI do
   (http://en.wikipedia.org/wiki/ANSI_escape_code) —  characters embedded
   in the text used to control formatting, color, and other output options
   on video text terminals.
-
-  Please be aware that in Erlang/OTP versions prior to R16, you will not
-  be able to render ANSI escape sequences in iex or erlang shell
   """
 
   import IO.ANSI.Sequence
@@ -36,23 +33,11 @@ defmodule IO.ANSI do
 
   Used to identify whether printing ANSI escape sequences will likely
   be printed as intended.
-
-  Please note that invoked while in shell (iex) in Erlang/OTP
-  prior to R16, terminal?/0 will always return false because
-  Erlang shell did not support ANSI escape sequences up until
-  R16.
   """
   @spec terminal? :: boolean
   @spec terminal?(:io.device) :: boolean
   def terminal?(device // :erlang.group_leader) do
-    if :erlang.system_info(:otp_release) < 'R16' and
-       Process.whereis(:user) != device do
-      # Shell prior to R16 doesn't support ANSI escape
-      # sequences
-      false
-    else
-      match?({:ok, _}, :io.columns(device))
-    end
+    match?({:ok, _}, :io.columns(device))
   end
 
   @doc "Resets all attributes"

lib/elixir/lib/kernel.ex

@@ -2000,41 +2000,18 @@ defmodule Kernel do
   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
+    quote do: :erlang.insert_element(unquote(index + 1), unquote(tuple), unquote(value))
   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
+  defmacro insert_elem(tuple, index, value) do
+    quote do: :erlang.insert_element(unquote(index) + 1, unquote(tuple), unquote(value))
   end
 
   @doc """
@@ -2053,30 +2030,11 @@ defmodule Kernel do
       { :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
+    quote do: :erlang.delete_element(unquote(index + 1), unquote(tuple))
   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
+  defmacro delete_elem(tuple, index) do
+    quote do: :erlang.delete_element(unquote(index) + 1, unquote(tuple))
   end
 
   @doc """
@@ -2654,15 +2612,7 @@ defmodule Kernel do
       123
 
   """
-  defmacro binary_to_integer(some_binary) do
-    case :proplists.get_value(:binary_to_integer,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      2 ->
-        quote do: :erlang.binary_to_integer(unquote(some_binary))
-      :undefined ->
-        quote do: list_to_integer(binary_to_list(unquote(some_binary)))
-    end
-  end
+  def binary_to_integer(some_binary)
 
   @doc """
   Returns an integer whose text representation in base `base`
@@ -2674,15 +2624,7 @@ defmodule Kernel do
       1023
 
   """
-  defmacro binary_to_integer(some_binary, base) do
-    case :proplists.get_value(:binary_to_integer,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      2 ->
-        quote do: :erlang.binary_to_integer(unquote(some_binary), unquote(base))
-      :undefined ->
-        quote do: list_to_integer(binary_to_list(unquote(some_binary)), unquote(base))
-    end
-  end
+  def binary_to_integer(some_binary, base)
 
   @doc """
   Returns a float whose text representation is `some_binary`.
@@ -2693,15 +2635,7 @@ defmodule Kernel do
       2.2017764
 
   """
-  defmacro binary_to_float(some_binary) do
-    case :proplists.get_value(:binary_to_float,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      1 ->
-        quote do: :erlang.binary_to_float(unquote(some_binary))
-      :undefined ->
-        quote do: list_to_float(binary_to_list(unquote(some_binary)))
-    end
-  end
+  def binary_to_float(some_binary)
 
   @doc """
   Returns a binary which corresponds to the text representation
@@ -2713,35 +2647,19 @@ defmodule Kernel do
       "123"
 
   """
-  defmacro integer_to_binary(some_integer) do
-    case :proplists.get_value(:integer_to_binary,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      2 ->
-        quote do: :erlang.integer_to_binary(unquote(some_integer))
-      :undefined ->
-        quote do: list_to_binary(integer_to_list(unquote(some_integer)))
-    end
-  end
+  def integer_to_binary(some_integer)
 
   @doc """
   Returns a binary which corresponds to the text representation
   of `some_integer` in base `base`.
 
   ## Examples
 
-      iex> integer_to_binary(77)
-      "77"
+      iex> integer_to_binary(100, 16)
+      "64"
 
   """
-  defmacro integer_to_binary(some_integer, base) do
-    case :proplists.get_value(:integer_to_binary,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      2 ->
-        quote do: :erlang.integer_to_binary(unquote(some_integer), unquote(base))
-      :undefined ->
-        quote do: list_to_binary(integer_to_list(unquote(some_integer), unquote(base)))
-    end
-  end
+  def integer_to_binary(some_integer, base)
 
   @doc """
   Returns a binary which corresponds to the text representation
@@ -2753,15 +2671,7 @@ defmodule Kernel do
       "7.00000000000000000000e+00"
 
   """
-  defmacro float_to_binary(some_float) do
-    case :proplists.get_value(:float_to_binary,
-                              :proplists.get_value(:exports, :erlang.module_info, [])) do
-      2 ->
-        quote do: :erlang.float_to_binary(unquote(some_float))
-      :undefined ->
-        quote do: list_to_binary(float_to_list(unquote(some_float)))
-    end
-  end
+  def float_to_binary(some_float)
 
   @doc """
   Returns a binary which corresponds to the text representation
@@ -2782,6 +2692,18 @@ defmodule Kernel do
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
+  @doc """
+  Returns a list which corresponds to the char list representation
+  of `some_float`.
+
+  ## Examples
+
+      iex> float_to_binary(7.0)
+      '7.00000000000000000000e+00'
+
+  """
+  def float_to_list(some_float)
+
   @doc """
   Returns a list which corresponds to the text representation
   of `float`.

lib/elixir/lib/list/chars.ex

@@ -34,20 +34,11 @@ defimpl List.Chars, for: Number do
     integer_to_list(thing)
   end
 
-  to_list = :proplists.get_value(:float_to_list,
-              :proplists.get_value(:exports, :erlang.module_info, []))
-
-  if to_list == 2 do
-    def to_char_list(thing) when thing > @limit do
-      float_to_list(thing, scientific: @digits)
-    end
-
-    def to_char_list(thing) do
-      float_to_list(thing, compact: true, decimals: @digits)
-    end
-  else
-    def to_char_list(thing) do
-      float_to_list(thing)
-    end
+  def to_char_list(thing) when thing > @limit do
+    float_to_list(thing, scientific: @digits)
   end
-end
+
+  def to_char_list(thing) do
+    float_to_list(thing, compact: true, decimals: @digits)
+  end
+end

lib/elixir/lib/system.ex

@@ -294,19 +294,11 @@ defmodule System do
   def halt(status // 0, options // [])
 
   def halt(status, options) when is_integer(status) or status == :abort do
-    do_halt(status, options)
+    :erlang.halt(status, options)
   end
 
   def halt(status, options) do
-    do_halt(to_char_list(status), options)
-  end
-
-  # Support R15B
-  if { :halt, 2 } in :erlang.module_info(:exports) do
-    defp do_halt(status, options),  do: :erlang.halt(status, options)
-  else
-    IO.puts "Using limited halt support. Upgrade to R15B01 or later is recommended."
-    defp do_halt(status, _options), do: :erlang.halt(status)
+    :erlang.halt(to_char_list(status), options)
   end
 
   ## Helpers

lib/elixir/rebar.config

@@ -24,4 +24,4 @@
             {verbose, false}
            ]}.
 
-{require_otp_vsn,"(R15|R16).*"}.
+{require_otp_vsn,"(R16).*"}.