Rename non_empty_list/2 -> non_empty_maybe_improper_list/2

Author: sabiwara

lib/elixir/lib/module/types/apply.ex

@@ -224,12 +224,13 @@ defmodule Module.Types.Apply do
         {:erlang, :++,
          [
            {[empty_list(), term()], dynamic(term())},
-           {[non_empty_list(term()), term()], dynamic(non_empty_list(term(), term()))}
+           {[non_empty_list(term()), term()],
+            dynamic(non_empty_maybe_improper_list(term(), term()))}
          ]},
         {:erlang, :--, [{[list(term()), list(term())], dynamic(list(term()))}]},
         {:erlang, :andalso, [{[boolean(), term()], dynamic()}]},
         {:erlang, :delete_element, [{[integer(), open_tuple([])], dynamic(open_tuple([]))}]},
-        {:erlang, :hd, [{[non_empty_list(term(), term())], dynamic()}]},
+        {:erlang, :hd, [{[non_empty_maybe_improper_list(term(), term())], dynamic()}]},
         {:erlang, :element, [{[integer(), open_tuple([])], dynamic()}]},
         {:erlang, :insert_element,
          [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
@@ -239,7 +240,7 @@ defmodule Module.Types.Apply do
         {:erlang, :orelse, [{[boolean(), term()], dynamic()}]},
         {:erlang, :send, [{[send_destination, term()], dynamic()}]},
         {:erlang, :setelement, [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
-        {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
+        {:erlang, :tl, [{[non_empty_maybe_improper_list(term(), term())], dynamic()}]},
         {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]}
       ] do
     [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
@@ -314,11 +315,11 @@ defmodule Module.Types.Apply do
   end
 
   def remote_domain(:erlang, :hd, [_list], expected, _meta, _stack, context) do
-    {:hd, [non_empty_list(expected, term())], context}
+    {:hd, [non_empty_maybe_improper_list(expected, term())], context}
   end
 
   def remote_domain(:erlang, :tl, [_list], _expected, _meta, _stack, context) do
-    {:tl, [non_empty_list(term(), term())], context}
+    {:tl, [non_empty_maybe_improper_list(term(), term())], context}
   end
 
   def remote_domain(:erlang, name, [_left, _right], _expected, _meta, stack, context)
@@ -1151,7 +1152,7 @@ defmodule Module.Types.Apply do
     args_docs_to_quoted_string(converter.(docs))
   end
 
-  @composite_types non_empty_list(term(), term())
+  @composite_types non_empty_maybe_improper_list(term(), term())
                    |> union(tuple())
                    |> union(open_map())
                    |> union(fun())

lib/elixir/lib/module/types/descr.ex

@@ -74,7 +74,8 @@ defmodule Module.Types.Descr do
   def float(), do: %{bitmap: @bit_float}
   def fun(), do: %{bitmap: @bit_fun}
   def list(type), do: list_descr(type, @empty_list, true)
-  def non_empty_list(type, tail \\ @empty_list), do: list_descr(type, tail, false)
+  def non_empty_list(type), do: list_descr(type, @empty_list, false)
+  def non_empty_maybe_improper_list(type, tail), do: list_descr(type, tail, false)
   def improper_list(), do: improper_list(term(), term())
   def improper_list(type, :term), do: list_descr(type, @not_list, false)
   def improper_list(type, tail), do: list_descr(type, difference(tail, list(term())), false)

lib/elixir/lib/module/types/expr.ex

@@ -109,7 +109,7 @@ defmodule Module.Types.Expr do
           of_expr(suffix, tl_type, expr, stack, context)
         end
 
-      {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
+      {non_empty_maybe_improper_list(Enum.reduce(prefix, &union/2), suffix), context}
     end
   end
 

lib/elixir/lib/module/types/of.ex

@@ -132,7 +132,7 @@ defmodule Module.Types.Of do
     {Float, float()},
     {Function, fun()},
     {Integer, integer()},
-    {List, union(empty_list(), non_empty_list(term(), term()))},
+    {List, union(empty_list(), non_empty_maybe_improper_list(term(), term()))},
     {Map, open_map(__struct__: if_set(negation(atom())))},
     {Port, port()},
     {PID, pid()},

lib/elixir/lib/module/types/pattern.ex

@@ -345,7 +345,7 @@ defmodule Module.Types.Pattern do
   def of_pattern_tree({:non_empty_list, [head | tail], suffix}, context) do
     tail
     |> Enum.reduce(of_pattern_tree(head, context), &union(of_pattern_tree(&1, context), &2))
-    |> non_empty_list(of_pattern_tree(suffix, context))
+    |> non_empty_maybe_improper_list(of_pattern_tree(suffix, context))
   end
 
   def of_pattern_tree({:intersection, entries}, context) do
@@ -639,7 +639,7 @@ defmodule Module.Types.Pattern do
 
     case {static, dynamic} do
       {static, []} when is_descr(suffix) ->
-        {non_empty_list(Enum.reduce(static, &union/2), suffix), context}
+        {non_empty_maybe_improper_list(Enum.reduce(static, &union/2), suffix), context}
 
       {[], dynamic} ->
         {{:non_empty_list, dynamic, suffix}, context}
@@ -685,7 +685,7 @@ defmodule Module.Types.Pattern do
       Enum.map_reduce(prefix, context, &of_guard(&1, term(), expr, stack, &2))
 
     {suffix, context} = of_guard(suffix, term(), expr, stack, context)
-    {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
+    {non_empty_maybe_improper_list(Enum.reduce(prefix, &union/2), suffix), context}
   end
 
   # {left, right}

lib/elixir/test/elixir/module/types/descr_test.exs

@@ -44,7 +44,7 @@ defmodule Module.Types.DescrTest do
         float(),
         binary(),
         open_map(),
-        non_empty_list(term(), term()),
+        non_empty_maybe_improper_list(term(), term()),
         empty_list(),
         tuple(),
         fun(),
@@ -435,7 +435,8 @@ defmodule Module.Types.DescrTest do
       refute empty?(difference(open_map(), empty_map()))
     end
 
-    defp list(elem_type, tail_type), do: union(empty_list(), non_empty_list(elem_type, tail_type))
+    defp list(elem_type, tail_type),
+      do: union(empty_list(), non_empty_maybe_improper_list(elem_type, tail_type))
 
     test "list" do
       # Basic list type differences
@@ -471,35 +472,44 @@ defmodule Module.Types.DescrTest do
              |> equal?(list(atom()))
 
       assert difference(list(integer(), float()), list(number(), integer()))
-             |> equal?(non_empty_list(integer(), difference(float(), integer())))
+             |> equal?(non_empty_maybe_improper_list(integer(), difference(float(), integer())))
 
       # Empty list with last element
       assert difference(empty_list(), list(integer(), atom())) == none()
 
       assert difference(list(integer(), atom()), empty_list()) ==
-               non_empty_list(integer(), atom())
+               non_empty_maybe_improper_list(integer(), atom())
 
       # List with any type and specific last element
       assert difference(list(term(), term()), list(term(), integer()))
              |> equal?(
-               non_empty_list(term(), negation(union(integer(), non_empty_list(term(), term()))))
+               non_empty_maybe_improper_list(
+                 term(),
+                 negation(union(integer(), non_empty_maybe_improper_list(term(), term())))
+               )
              )
 
       # Nested lists with last element
       assert difference(list(list(integer()), atom()), list(list(number()), boolean()))
              |> equal?(
                union(
-                 non_empty_list(list(integer()), difference(atom(), boolean())),
-                 non_empty_list(difference(list(integer()), list(number())), atom())
+                 non_empty_maybe_improper_list(list(integer()), difference(atom(), boolean())),
+                 non_empty_maybe_improper_list(
+                   difference(list(integer()), list(number())),
+                   atom()
+                 )
                )
              )
 
       # Union types in last element
       assert difference(list(integer(), union(atom(), binary())), list(number(), atom()))
              |> equal?(
                union(
-                 non_empty_list(integer(), binary()),
-                 non_empty_list(difference(integer(), number()), union(atom(), binary()))
+                 non_empty_maybe_improper_list(integer(), binary()),
+                 non_empty_maybe_improper_list(
+                   difference(integer(), number()),
+                   union(atom(), binary())
+                 )
                )
              )
 
@@ -511,7 +521,7 @@ defmodule Module.Types.DescrTest do
 
       # Difference with proper list
       assert difference(list(integer(), atom()), list(integer())) ==
-               non_empty_list(integer(), atom())
+               non_empty_maybe_improper_list(integer(), atom())
     end
   end
 
@@ -719,8 +729,10 @@ defmodule Module.Types.DescrTest do
 
       # If term() is in the tail, it means list(term()) is in the tail
       # and therefore any term can be returned from hd.
-      assert list_hd(non_empty_list(atom(), term())) == {false, term()}
-      assert list_hd(non_empty_list(atom(), negation(list(term(), term())))) == {false, atom()}
+      assert list_hd(non_empty_maybe_improper_list(atom(), term())) == {false, term()}
+
+      assert list_hd(non_empty_maybe_improper_list(atom(), negation(list(term(), term())))) ==
+               {false, atom()}
     end
 
     test "list_tl" do
@@ -732,18 +744,26 @@ defmodule Module.Types.DescrTest do
 
       assert list_tl(non_empty_list(integer())) == {false, list(integer())}
 
-      assert list_tl(non_empty_list(integer(), atom())) ==
-               {false, union(atom(), non_empty_list(integer(), atom()))}
+      assert list_tl(non_empty_maybe_improper_list(integer(), atom())) ==
+               {false, union(atom(), non_empty_maybe_improper_list(integer(), atom()))}
 
       # The tail of either a (non empty) list of integers with an atom tail or a (non empty) list
       # of tuples with a float tail is either an atom, or a float, or a (possibly empty) list of
       # integers with an atom tail, or a (possibly empty) list of tuples with a float tail.
-      assert list_tl(union(non_empty_list(integer(), atom()), non_empty_list(tuple(), float()))) ==
+      assert list_tl(
+               union(
+                 non_empty_maybe_improper_list(integer(), atom()),
+                 non_empty_maybe_improper_list(tuple(), float())
+               )
+             ) ==
                {false,
                 atom()
                 |> union(float())
                 |> union(
-                  union(non_empty_list(integer(), atom()), non_empty_list(tuple(), float()))
+                  union(
+                    non_empty_maybe_improper_list(integer(), atom()),
+                    non_empty_maybe_improper_list(tuple(), float())
+                  )
                 )}
 
       assert list_tl(dynamic()) == {true, dynamic()}

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -36,13 +36,13 @@ defmodule Module.Types.ExprTest do
   describe "lists" do
     test "creating lists" do
       assert typecheck!([1, 2]) == non_empty_list(integer())
-      assert typecheck!([1, 2 | 3]) == non_empty_list(integer(), integer())
+      assert typecheck!([1, 2 | 3]) == non_empty_maybe_improper_list(integer(), integer())
       assert typecheck!([1, 2 | [3, 4]]) == non_empty_list(integer())
 
       assert typecheck!([:ok, 123]) == non_empty_list(union(atom([:ok]), integer()))
-      assert typecheck!([:ok | 123]) == non_empty_list(atom([:ok]), integer())
+      assert typecheck!([:ok | 123]) == non_empty_maybe_improper_list(atom([:ok]), integer())
       assert typecheck!([x], [:ok, x]) == dynamic(non_empty_list(term()))
-      assert typecheck!([x], [:ok | x]) == dynamic(non_empty_list(term(), term()))
+      assert typecheck!([x], [:ok | x]) == dynamic(non_empty_maybe_improper_list(term(), term()))
     end
 
     test "inference" do
@@ -94,7 +94,9 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([x = [123, :foo]], tl(x)) == dynamic(list(union(atom([:foo]), integer())))
 
       assert typecheck!([x = [123 | :foo]], tl(x)) ==
-               dynamic(union(atom([:foo]), non_empty_list(integer(), atom([:foo]))))
+               dynamic(
+                 union(atom([:foo]), non_empty_maybe_improper_list(integer(), atom([:foo])))
+               )
 
       assert typeerror!(tl([])) |> strip_ansi() ==
                ~l"""

lib/elixir/test/elixir/module/types/integration_test.exs

@@ -208,7 +208,7 @@ defmodule Module.Types.IntegrationTest do
       assert itself_arg.(Itself.Integer) == dynamic(integer())
 
       assert itself_arg.(Itself.List) ==
-               dynamic(union(empty_list(), non_empty_list(term(), term())))
+               dynamic(union(empty_list(), non_empty_maybe_improper_list(term(), term())))
 
       assert itself_arg.(Itself.Map) == dynamic(open_map(__struct__: if_set(negation(atom()))))
       assert itself_arg.(Itself.Port) == dynamic(port())
@@ -487,7 +487,7 @@ defmodule Module.Types.IntegrationTest do
                 dynamic(
                   %Date{} or %DateTime{} or %NaiveDateTime{} or %Time{} or %URI{} or %Version{} or
                     %Version.Requirement{}
-                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_list(term(), term())
+                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_maybe_improper_list(term(), term())
 
             where "data" was given the type:
 
@@ -511,7 +511,7 @@ defmodule Module.Types.IntegrationTest do
                 dynamic(
                   %Date{} or %DateTime{} or %NaiveDateTime{} or %Time{} or %URI{} or %Version{} or
                     %Version.Requirement{}
-                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_list(term(), term())
+                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_maybe_improper_list(term(), term())
 
             where "data" was given the type:
 
@@ -551,7 +551,7 @@ defmodule Module.Types.IntegrationTest do
                 dynamic(
                   %Date.Range{} or %File.Stream{} or %GenEvent.Stream{} or %HashDict{} or %HashSet{} or
                     %IO.Stream{} or %MapSet{} or %Range{} or %Stream{}
-                ) or empty_list() or fun() or non_empty_list(term(), term()) or non_struct_map()
+                ) or empty_list() or fun() or non_empty_maybe_improper_list(term(), term()) or non_struct_map()
 
             where "date" was given the type:
 
@@ -580,7 +580,7 @@ defmodule Module.Types.IntegrationTest do
             but expected a type that implements the Collectable protocol, it must be one of:
 
                 dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or binary() or
-                  empty_list() or non_empty_list(term(), term()) or non_struct_map()
+                  empty_list() or non_empty_maybe_improper_list(term(), term()) or non_struct_map()
 
             hint: the :into option in for-comprehensions use the Collectable protocol to build its result. Either pass a valid data type or implement the protocol accordingly
         """

lib/elixir/test/elixir/module/types/pattern_test.exs

@@ -213,16 +213,16 @@ defmodule Module.Types.PatternTest do
                dynamic(non_empty_list(integer()))
 
       assert typecheck!([x = [1, 2, 3 | y], y = :foo], x) ==
-               dynamic(non_empty_list(integer(), atom([:foo])))
+               dynamic(non_empty_maybe_improper_list(integer(), atom([:foo])))
 
       assert typecheck!([x = [1, 2, 3 | y], y = [1.0, 2.0, 3.0]], x) ==
                dynamic(non_empty_list(union(integer(), float())))
 
       assert typecheck!([x = [:ok | z]], {x, z}) ==
-               dynamic(tuple([non_empty_list(term(), term()), term()]))
+               dynamic(tuple([non_empty_maybe_improper_list(term(), term()), term()]))
 
       assert typecheck!([x = [y | z]], {x, y, z}) ==
-               dynamic(tuple([non_empty_list(term(), term()), term(), term()]))
+               dynamic(tuple([non_empty_maybe_improper_list(term(), term()), term(), term()]))
     end
 
     test "in patterns through ++" do
@@ -232,7 +232,7 @@ defmodule Module.Types.PatternTest do
                dynamic(atom([:foo]))
 
       assert typecheck!([x = [1, 2, 3] ++ y, y = :foo], x) ==
-               dynamic(non_empty_list(integer(), atom([:foo])))
+               dynamic(non_empty_maybe_improper_list(integer(), atom([:foo])))
 
       assert typecheck!([x = [1, 2, 3] ++ y, y = [1.0, 2.0, 3.0]], x) ==
                dynamic(non_empty_list(union(integer(), float())))