Range is no longer a record

The goal is to simplify and allow us to extend ranges in the future.
Also, incentivate people to use `first .. last` in pattern matching
instead of `Range[first: first, last: last]`.

Author: José Valim

lib/elixir/lib/range.ex

@@ -1,7 +1,31 @@
-defrecord Range, [:first, :last] do
+defmodule Range do
   @moduledoc """
   Defines a Range.
   """
+
+  @type t :: { Range, any, any }
+  @type t(first, last) :: { Range, first, last }
+
+  @doc """
+  Creates a new range.
+  """
+  def new(first, last) do
+    { Range, first, last }
+  end
+
+  @doc """
+  Returns the first item of the range.
+  """
+  def first({ Range, first, _ }) do
+    first
+  end
+
+  @doc """
+  Returns the last item of the range.
+  """
+  def last({ Range, _, last }) do
+    last
+  end
 end
 
 defprotocol Range.Iterator do
@@ -55,15 +79,15 @@ defimpl Enumerable, for: Range do
 end
 
 defimpl Range.Iterator, for: Integer do
-  def next(first, Range[last: last]) when is_integer(last) do
+  def next(first, _ .. last) when is_integer(last) do
     if last >= first do
       &(&1 + 1)
     else
       &(&1 - 1)
     end
   end
 
-  def count(first, Range[last: last]) when is_integer(last) do
+  def count(first, _ .. last) when is_integer(last) do
     if last >= first do
       last - first + 1
     else
@@ -75,7 +99,7 @@ end
 defimpl Inspect, for: Range do
   import Inspect.Algebra
 
-  def inspect(Range[first: first, last: last], opts) do
+  def inspect(first .. last, opts) do
     concat [to_doc(first, opts), "..", to_doc(last, opts)]
   end
 end

lib/elixir/test/elixir/kernel/record_rewriter_test.exs

@@ -1,6 +1,8 @@
 Code.require_file "../test_helper.exs", __DIR__
 
-defrecord BadRange, first: 0, last: 0 do
+defrecord Rec, first: 0, last: 0
+
+defrecord BadRec, first: 0, last: 0 do
   defoverridable [first: 1]
 
   def first(_) do
@@ -67,11 +69,11 @@ defmodule Kernel.RecordRewriterTest do
   end
 
   test "with tuple match" do
-    clause = clause(fn({ x, y } = { Macro.Env[], Range[] }) -> :foo end)
-    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Range], nil }
+    clause = clause(fn({ x, y } = { Macro.Env[], Rec[] }) -> :foo end)
+    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Rec], nil }
 
-    clause = clause(fn({ Macro.Env[], y } = { x, Range[] }) -> :foo end)
-    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Range], nil }
+    clause = clause(fn({ Macro.Env[], y } = { x, Rec[] }) -> :foo end)
+    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Rec], nil }
   end
 
   test "inside body" do
@@ -80,13 +82,13 @@ defmodule Kernel.RecordRewriterTest do
   end
 
   test "inside body with variable overridden" do
-    clause = clause(fn(x = Macro.Env[], y = Range[]) -> y = x end)
-    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Range, "y@1": Macro.Env], { Macro.Env, nil } }
+    clause = clause(fn(x = Macro.Env[], y = Rec[]) -> y = x end)
+    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Rec, "y@1": Macro.Env], { Macro.Env, nil } }
   end
 
   test "inside body with nested tuple" do
-    clause = clause(fn(x = Range[]) -> ^x = Range[first: { :hello, 2 }] end)
-    assert optimize_clause(clause) == { clause, [x: Range], { Range, [nil, { :hello, nil }, nil] } }
+    clause = clause(fn(x = Rec[]) -> ^x = Rec[first: { :hello, 2 }] end)
+    assert optimize_clause(clause) == { clause, [x: Rec], { Rec, [nil, { :hello, nil }, nil] } }
   end
 
   test "with setelement" do
@@ -102,7 +104,7 @@ defmodule Kernel.RecordRewriterTest do
   end
 
   test "conflicting definition" do
-    clause = clause(fn(x = Macro.Env[]) -> ^x = Range[]; :foo end)
+    clause = clause(fn(x = Macro.Env[]) -> ^x = Rec[]; :foo end)
     assert optimize_clause(clause) == { clause, [x: nil], nil }
   end
 
@@ -132,13 +134,13 @@ defmodule Kernel.RecordRewriterTest do
   end
 
   test "inside local call" do
-    clause = clause(fn -> (x = Macro.Env[]).(y = Range[]) end)
-    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Range], nil }
+    clause = clause(fn -> (x = Macro.Env[]).(y = Rec[]) end)
+    assert optimize_clause(clause) == { clause, [x: Macro.Env, y: Rec], nil }
   end
 
   test "inside remote call" do
-    clause = clause(fn -> x.call(y = Range[]) end)
-    assert optimize_clause(clause) == { clause, [y: Range], nil }
+    clause = clause(fn -> x.call(y = Rec[]) end)
+    assert optimize_clause(clause) == { clause, [y: Rec], nil }
   end
 
   test "inside list comprehension" do
@@ -161,19 +163,19 @@ defmodule Kernel.RecordRewriterTest do
     clause = clause(fn -> case something do 1 -> x = Macro.Env[]; 2 -> x = Macro.Env[] end end)
     assert optimize_clause(clause) == { clause, [x: Macro.Env], { Macro.Env, nil } }
 
-    clause = clause(fn -> case something do 1 -> x = Macro.Env[]; 2 -> x = Range[] end end)
+    clause = clause(fn -> case something do 1 -> x = Macro.Env[]; 2 -> x = Rec[] end end)
     assert optimize_clause(clause) == { clause, [x: nil], nil }
 
-    clause = clause(fn -> case something do x = Macro.Env[] -> x; x = Range[] -> x; _ -> :ok end end)
+    clause = clause(fn -> case something do x = Macro.Env[] -> x; x = Rec[] -> x; _ -> :ok end end)
     assert optimize_clause(clause) == { clause, [], nil }
   end
 
   test "inside case with nested tuple" do
-    clause = clause(fn -> case something do x = Range[first: { :foo, 2 }] -> x = x; Range[] = x -> x = x end end)
-    assert optimize_clause(clause) == { clause, ["x@4": Range], { Range, nil } }
+    clause = clause(fn -> case something do x = Rec[first: { :foo, 2 }] -> x = x; Rec[] = x -> x = x end end)
+    assert optimize_clause(clause) == { clause, ["x@4": Rec], { Rec, nil } }
 
-    clause = clause(fn -> case something do x = Range[first: { :foo, 2 }] -> x = x; Range[first: { :foo, 2 }] = x -> x = x end end)
-    assert optimize_clause(clause) == { clause, ["x@4": Range], { Range, [nil, { :foo, nil }, nil] } }
+    clause = clause(fn -> case something do x = Rec[first: { :foo, 2 }] -> x = x; Rec[first: { :foo, 2 }] = x -> x = x end end)
+    assert optimize_clause(clause) == { clause, ["x@4": Rec], { Rec, [nil, { :foo, nil }, nil] } }
   end
 
   test "empty receive" do
@@ -188,15 +190,15 @@ defmodule Kernel.RecordRewriterTest do
     clause = clause(fn -> receive do 1 -> x = Macro.Env[]; 2 -> x = Macro.Env[] end end)
     assert optimize_clause(clause) == { clause, [x: Macro.Env], { Macro.Env, nil } }
 
-    clause = clause(fn -> receive do 1 -> x = Macro.Env[]; 2 -> x = Range[] end end)
+    clause = clause(fn -> receive do 1 -> x = Macro.Env[]; 2 -> x = Rec[] end end)
     assert optimize_clause(clause) == { clause, [x: nil], nil }
   end
 
   test "inside receive with after" do
     clause = clause(fn -> receive do 1 -> x = Macro.Env[]; after 2 -> x = Macro.Env[]; end end)
     assert optimize_clause(clause) == { clause, [x: Macro.Env], { Macro.Env, nil } }
 
-    clause = clause(fn -> receive do 1 -> x = Macro.Env[]; after 2 -> x = Range[]; end end)
+    clause = clause(fn -> receive do 1 -> x = Macro.Env[]; after 2 -> x = Rec[]; end end)
     assert optimize_clause(clause) == { clause, [x: nil], nil }
   end
 
@@ -215,54 +217,54 @@ defmodule Kernel.RecordRewriterTest do
 
   test "getter call is rewriten" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.first end), clause(fn(x = Range[]) -> :erlang.element(2, x) end) }
+      { clause(fn(x = Rec[]) -> x.first end), clause(fn(x = Rec[]) -> :erlang.element(2, x) end) }
 
-    assert optimize_clause(clause) == { rewriten, [x: Range], nil }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], nil }
   end
 
   test "direct getter call is rewriten" do
     { clause, rewriten } =
-      { clause(fn() -> Range[].first end), clause(fn() -> :erlang.element(2, Range[]) end) }
+      { clause(fn() -> Rec[].first end), clause(fn() -> :erlang.element(2, Rec[]) end) }
 
     assert optimize_clause(clause) == { rewriten, [], nil }
   end
 
   test "setter call is rewriten" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.first(:first) end), clause(fn(x = Range[]) -> :erlang.setelement(2, x, :first) end) }
+      { clause(fn(x = Rec[]) -> x.first(:first) end), clause(fn(x = Rec[]) -> :erlang.setelement(2, x, :first) end) }
 
-    assert optimize_clause(clause) == { rewriten, [x: Range], { Range, nil } }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], { Rec, nil } }
   end
 
   test "nested setter call is rewriten" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.first(:first).last(:last) end), clause(fn(x = Range[]) -> :erlang.setelement(3, :erlang.setelement(2, x, :first), :last) end) }
+      { clause(fn(x = Rec[]) -> x.first(:first).last(:last) end), clause(fn(x = Rec[]) -> :erlang.setelement(3, :erlang.setelement(2, x, :first), :last) end) }
 
-    assert optimize_clause(clause) == { rewriten, [x: Range], { Range, nil } }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], { Rec, nil } }
   end
 
   test "updater call is rewriten" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.update_first(&(&1 + 1)) end), clause(fn(x = Range[]) -> Range.update_first(&(&1 + 1), x) end) }
-    assert optimize_clause(clause) == { rewriten, [x: Range], { Range, nil } }
+      { clause(fn(x = Rec[]) -> x.update_first(&(&1 + 1)) end), clause(fn(x = Rec[]) -> Rec.update_first(&(&1 + 1), x) end) }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], { Rec, nil } }
   end
 
   test "update call is rewriten" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.update(first: 1) end), clause(fn(x = Range[]) -> Range.update([first: 1], x) end) }
-    assert optimize_clause(clause) == { rewriten, [x: Range], { Range, nil } }
+      { clause(fn(x = Rec[]) -> x.update(first: 1) end), clause(fn(x = Rec[]) -> Rec.update([first: 1], x) end) }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], { Rec, nil } }
   end
 
   test "fallback for unknown fields" do
     { clause, rewriten } =
-      { clause(fn(x = Range[]) -> x.unknown(1, 2) end), clause(fn(x = Range[]) -> Range.unknown(1, 2, x) end) }
-    assert optimize_clause(clause) == { rewriten, [x: Range], nil }
+      { clause(fn(x = Rec[]) -> x.unknown(1, 2) end), clause(fn(x = Rec[]) -> Rec.unknown(1, 2, x) end) }
+    assert optimize_clause(clause) == { rewriten, [x: Rec], nil }
   end
 
   test "fallback for rewriten fields" do
     { clause, rewriten } =
-      { clause(fn(x = BadRange[]) -> x.first end), clause(fn(x = BadRange[]) -> BadRange.first(x) end) }
-    assert optimize_clause(clause) == { rewriten, [x: BadRange], nil }
+      { clause(fn(x = BadRec[]) -> x.first end), clause(fn(x = BadRec[]) -> BadRec.first(x) end) }
+    assert optimize_clause(clause) == { rewriten, [x: BadRec], nil }
   end
 
   test "noop for not records fields" do
@@ -271,7 +273,7 @@ defmodule Kernel.RecordRewriterTest do
   end
 
   test "noop for conflicting inference" do
-    clause = clause(fn(x = Macro.Env[]) -> ^x = Range[]; x.first end)
+    clause = clause(fn(x = Macro.Env[]) -> ^x = Rec[]; x.first end)
     assert optimize_clause(clause) == { clause, [x: nil], nil }
   end
 end

lib/elixir/test/elixir/protocol_test.exs

@@ -64,7 +64,7 @@ defmodule ProtocolTest do
     assert nil? Sample.impl_for(self)
     assert nil? Sample.impl_for(hd(:erlang.ports))
     assert nil? Sample.impl_for(make_ref)
-    assert nil? Sample.impl_for(Range[])
+    assert nil? Sample.impl_for(Macro.Env[])
 
     assert Sample.impl_for(Foo[]) ==
            Sample.ProtocolTest.Foo
@@ -73,10 +73,10 @@ defmodule ProtocolTest do
   end
 
   test :protocol_priority_does_not_override_records do
-    assert WithAny.impl_for(Foo[])    == WithAny.ProtocolTest.Foo
-    assert WithAny.impl_for(Range[])  == WithAny.Tuple
-    assert WithAny.impl_for({ :foo }) == WithAny.Tuple
-    assert WithAny.impl_for({})       == WithAny.Tuple
+    assert WithAny.impl_for(Foo[])       == WithAny.ProtocolTest.Foo
+    assert WithAny.impl_for(Macro.Env[]) == WithAny.Tuple
+    assert WithAny.impl_for({ :foo })    == WithAny.Tuple
+    assert WithAny.impl_for({})          == WithAny.Tuple
   end
 
   test :protocol_with_fallback do
@@ -214,7 +214,7 @@ defmodule Protocol.ConsolidationTest do
     assert nil? Sample.impl_for(self)
     assert nil? Sample.impl_for(hd(:erlang.ports))
     assert nil? Sample.impl_for(make_ref)
-    assert nil? Sample.impl_for(Range[])
+    assert nil? Sample.impl_for(Macro.Env[])
 
     assert Sample.impl_for(Foo[]) ==
            Sample.Protocol.ConsolidationTest.Foo
@@ -223,10 +223,10 @@ defmodule Protocol.ConsolidationTest do
   end
 
   test :consolidated_impl_for_prioritized do
-    assert WithAny.impl_for(Foo[])    == WithAny.Protocol.ConsolidationTest.Foo
-    assert WithAny.impl_for(Range[])  == WithAny.Tuple
-    assert WithAny.impl_for({ :foo }) == WithAny.Tuple
-    assert WithAny.impl_for({})       == WithAny.Tuple
+    assert WithAny.impl_for(Foo[])       == WithAny.Protocol.ConsolidationTest.Foo
+    assert WithAny.impl_for(Macro.Env[]) == WithAny.Tuple
+    assert WithAny.impl_for({ :foo })    == WithAny.Tuple
+    assert WithAny.impl_for({})          == WithAny.Tuple
   end
 
   test :consolidated_fallback do

lib/elixir/test/elixir/range_test.exs

@@ -9,11 +9,11 @@ defmodule RangeTest do
   end
 
   test :first do
-    assert Range.new(first: 1, last: 3).first == 1
+    assert Range.first(1..3) == 1
   end
 
   test :last do
-    assert Range.new(first: 1, last: 3).last == 3
+    assert Range.last(1..3) == 3
   end
 
   test :op do
@@ -45,8 +45,6 @@ defmodule RangeTest do
   test :inspect do
     assert inspect(1..3) == "1..3"
     assert inspect(3..1) == "3..1"
-
-    # False positive
     assert inspect({ Range, nil }) == "{Range, nil}"
   end
 

lib/elixir/test/elixir/typespec_test.exs

@@ -3,6 +3,8 @@ Code.require_file "test_helper.exs", __DIR__
 defmodule Typespec.TypeTest do
   use ExUnit.Case, async: true
 
+  defrecord Rec, [:first, :last]
+
   # This macro allows us to focus on the result of the
   # definition and not on the hassles of handling test
   # module
@@ -188,8 +190,7 @@ defmodule Typespec.TypeTest do
 
   test "@type with a union" do
     spec = test_module do
-      @type mytype :: integer | char_list
-                    | atom
+      @type mytype :: integer | char_list | atom
     end
     assert {:mytype, {:type, _, :union, [{:type, _, :integer, []},
              {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]},
@@ -198,10 +199,10 @@ defmodule Typespec.TypeTest do
 
   test "@type with an access macro" do
     spec = test_module do
-      @type mytype :: Range[first: integer]
+      @type mytype :: Rec[first: integer]
     end
     assert {:mytype, {:type, _, :tuple,
-             [{:atom, _, Range}, {:type, _, :integer, []}, {:type, _, :any, []}]}, []} = spec
+             [{:atom, _, Rec}, {:type, _, :integer, []}, {:type, _, :any, []}]}, []} = spec
   end
 
   test "@type with keywords" do