Type hd/1 and tl/1

Author: josevalim

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

@@ -781,34 +781,29 @@ defmodule Module.Types.Descr do
   On a non empty list of integers, it returns the first integer.
   On a non empty list of integers, with an atom head element, it returns the atom.
   """
-  def list_hd(:term), do: :badlist
+  def list_hd(:term), do: :badnonemptylist
 
   def list_hd(%{} = descr) do
     case :maps.take(:dynamic, descr) do
       :error ->
         has_empty = empty_list_type?(descr)
         is_list_type = list_only?(descr)
 
-        cond do
-          is_list_type and not has_empty -> {false, list_hd_static(descr)}
-          is_list_type -> :empty_list
-          true -> :badlist
+        if is_list_type and not has_empty do
+          {false, list_hd_static(descr)}
+        else
+          :badnonemptylist
         end
 
       {dynamic, static} ->
         has_empty = empty_list_type?(static)
         only_list = list_only?(static)
         is_dynamic_list = list_type?(dynamic)
 
-        cond do
-          is_dynamic_list and only_list and not has_empty ->
-            {is_dynamic_list, union(dynamic(list_hd_static(dynamic)), list_hd_static(static))}
-
-          is_dynamic_list and only_list ->
-            :empty_list
-
-          true ->
-            :badlist
+        if is_dynamic_list and only_list and not has_empty do
+          {is_dynamic_list, union(dynamic(list_hd_static(dynamic)), list_hd_static(static))}
+        else
+          :badnonemptylist
         end
     end
   end
@@ -836,34 +831,29 @@ defmodule Module.Types.Descr do
   On a non empty list of integers, with an atom tail element, it returns either an atom,
   or a (possibly empty) list of integers with an atom tail element.
   """
-  def list_tl(:term), do: :badlist
+  def list_tl(:term), do: :badnonemptylist
 
   def list_tl(descr) do
     case :maps.take(:dynamic, descr) do
       :error ->
         has_empty = empty_list_type?(descr)
         is_list_type = list_only?(descr)
 
-        cond do
-          is_list_type and not has_empty -> {false, list_tl_static(descr)}
-          is_list_type -> :empty_list
-          true -> :badlist
+        if is_list_type and not has_empty do
+          {false, list_tl_static(descr)}
+        else
+          :badnonemptylist
         end
 
       {dynamic, static} ->
         has_empty = empty_list_type?(static)
         only_list = list_only?(static)
         is_dynamic_list = list_type?(dynamic)
 
-        cond do
-          is_dynamic_list and only_list and not has_empty ->
-            {is_dynamic_list, union(dynamic(list_tl_static(dynamic)), list_tl_static(static))}
-
-          is_dynamic_list and only_list ->
-            :empty_list
-
-          true ->
-            :badlist
+        if is_dynamic_list and only_list and not has_empty do
+          {is_dynamic_list, union(dynamic(list_tl_static(dynamic)), list_tl_static(static))}
+        else
+          :badnonemptylist
         end
     end
   end

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

@@ -342,6 +342,26 @@ defmodule Module.Types.Of do
     {tuple(List.duplicate(elem, size)), context}
   end
 
+  def apply(:erlang, :hd, [list], expr, stack, context) do
+    case list_hd(list) do
+      {_, value_type} ->
+        {value_type, context}
+
+      reason ->
+        {error_type(), error({reason, expr, list, context}, elem(expr, 1), stack, context)}
+    end
+  end
+
+  def apply(:erlang, :tl, [list], expr, stack, context) do
+    case list_tl(list) do
+      {_, value_type} ->
+        {value_type, context}
+
+      reason ->
+        {error_type(), error({reason, expr, list, context}, elem(expr, 1), stack, context)}
+    end
+  end
+
   def apply(:erlang, name, [left, right], expr, stack, context)
       when name in [:>=, :"=<", :>, :<, :min, :max] do
     result = if name in [:min, :max], do: union(left, right), else: boolean()
@@ -618,6 +638,27 @@ defmodule Module.Types.Of do
     }
   end
 
+  def format_diagnostic({:badnonemptylist, expr, type, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a non-empty list in expression:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
   def format_diagnostic({:badtuple, expr, type, _index, context}) do
     traces = collect_traces(expr, context)
 

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

@@ -592,17 +592,17 @@ defmodule Module.Types.DescrTest do
     end
 
     test "list_hd" do
-      assert list_hd(term()) == :badlist
-      assert list_hd(list(term())) == :empty_list
-      assert list_hd(empty_list()) == :empty_list
+      assert list_hd(term()) == :badnonemptylist
+      assert list_hd(list(term())) == :badnonemptylist
+      assert list_hd(empty_list()) == :badnonemptylist
       assert list_hd(non_empty_list(term())) == {false, term()}
       assert list_hd(non_empty_list(integer())) == {false, integer()}
       assert list_hd(difference(list(number()), list(integer()))) == {false, number()}
 
       assert list_hd(dynamic()) == {true, dynamic()}
       assert list_hd(dynamic(list(integer()))) == {true, dynamic(integer())}
-      assert list_hd(union(dynamic(), atom())) == :badlist
-      assert list_hd(union(dynamic(), list(term()))) == :empty_list
+      assert list_hd(union(dynamic(), atom())) == :badnonemptylist
+      assert list_hd(union(dynamic(), list(term()))) == :badnonemptylist
 
       assert list_hd(union(dynamic(list(float())), non_empty_list(atom()))) ==
                {true, union(dynamic(float()), atom())}
@@ -614,9 +614,9 @@ defmodule Module.Types.DescrTest do
     end
 
     test "list_tl" do
-      assert list_tl(term()) == :badlist
-      assert list_tl(empty_list()) == :empty_list
-      assert list_tl(list(integer())) == :empty_list
+      assert list_tl(term()) == :badnonemptylist
+      assert list_tl(empty_list()) == :badnonemptylist
+      assert list_tl(list(integer())) == :badnonemptylist
       assert list_tl(non_empty_list(integer())) == {false, list(integer())}
 
       assert list_tl(non_empty_list(integer(), atom())) ==

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

@@ -34,6 +34,71 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([1, 2]) == non_empty_list(integer())
       assert typecheck!([1, 2 | 3]) == non_empty_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!([x], [:ok, x]) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], [:ok | x]) == dynamic(non_empty_list(term(), term()))
+    end
+
+    test "hd" do
+      assert typecheck!([x = [123, :foo]], hd(x)) == dynamic(union(atom([:foo]), integer()))
+      assert typecheck!([x = [123 | :foo]], hd(x)) == dynamic(integer())
+
+      assert typewarn!(hd([])) ==
+               {dynamic(),
+                ~l"""
+                expected a non-empty list in expression:
+
+                    hd([])
+
+                but got type:
+
+                    empty_list()
+                """}
+
+      assert typewarn!(hd(123)) ==
+               {dynamic(),
+                ~l"""
+                expected a non-empty list in expression:
+
+                    hd(123)
+
+                but got type:
+
+                    integer()
+                """}
+    end
+
+    test "tl" 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]), list(integer(), atom([:foo]))))
+
+      assert typewarn!(tl([])) ==
+               {dynamic(),
+                ~l"""
+                expected a non-empty list in expression:
+
+                    tl([])
+
+                but got type:
+
+                    empty_list()
+                """}
+
+      assert typewarn!(tl(123)) ==
+               {dynamic(),
+                ~l"""
+                expected a non-empty list in expression:
+
+                    tl(123)
+
+                but got type:
+
+                    integer()
+                """}
     end
   end