Surface dynamic up in function creation

Author: josevalim

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

@@ -930,31 +930,19 @@ defmodule Module.Types.Descr do
   # Creates a function type from a list of inputs and an output
   # where the inputs and/or output may be dynamic.
   #
-  # For function (t → s) with dynamic components:
+  # One approach is, for function (t → s) with dynamic components:
   # - Static part: (upper_bound(t) → lower_bound(s))
   # - Dynamic part: dynamic(lower_bound(t) → upper_bound(s))
   #
-  # When handling dynamic types:
-  # - `upper_bound(t)` extracts the upper bound (most general type) of a gradual type.
-  #   For `dynamic(integer())`, it is `integer()`.
-  # - `lower_bound(t)` extracts the lower bound (most specific type) of a gradual type.
+  # However, this comes with the downside that `dynamic(integer()) -> binary()`
+  # cannot receive integers as arguments. So instead we surface the dynamic up,
+  # as we do for other data types, converting it to `dynamic((integer() -> binary()))`.
+  # One could obtain the other type if desired by explicitly defining it.
   defp fun_descr(args, output) when is_list(args) do
-    dynamic_arguments? = are_arguments_dynamic?(args)
-    dynamic_output? = match?(%{dynamic: _}, output)
-
-    if dynamic_arguments? or dynamic_output? do
-      input_static = if dynamic_arguments?, do: materialize_arguments(args, :up), else: args
-      input_dynamic = if dynamic_arguments?, do: materialize_arguments(args, :down), else: args
-
-      output_static = if dynamic_output?, do: lower_bound(output), else: output
-      output_dynamic = if dynamic_output?, do: upper_bound(output), else: output
-
-      %{
-        fun: fun_new(input_static, output_static),
-        dynamic: %{fun: fun_new(input_dynamic, output_dynamic)}
-      }
+    if any_dynamic?([output | args]) do
+      [output | args] = Enum.map([output | args], &upper_bound/1)
+      %{dynamic: %{fun: fun_new(args, output)}}
     else
-      # No dynamic components, use standard function type
       %{fun: fun_new(args, output)}
     end
   end
@@ -1027,7 +1015,7 @@ defmodule Module.Types.Descr do
   defp fun_only?(descr), do: empty?(Map.delete(descr, :fun))
 
   defp fun_apply_with_strategy(fun_static, fun_dynamic, arguments) do
-    args_dynamic? = are_arguments_dynamic?(arguments)
+    args_dynamic? = any_dynamic?(arguments)
     arity = length(arguments)
 
     # For non-dynamic function and arguments, just return the static result
@@ -1053,8 +1041,7 @@ defmodule Module.Types.Descr do
             # For dynamic cases, combine static and dynamic results
             {static_args, dynamic_args, maybe_empty?} =
               if args_dynamic? do
-                {materialize_arguments(arguments, :up), materialize_arguments(arguments, :down),
-                 true}
+                {Enum.map(arguments, &upper_bound/1), Enum.map(arguments, &lower_bound/1), true}
               else
                 {arguments, arguments, false}
               end
@@ -1069,11 +1056,7 @@ defmodule Module.Types.Descr do
     end
   end
 
-  # Materializes arguments using the specified direction (up or down)
-  defp materialize_arguments(arguments, :up), do: Enum.map(arguments, &upper_bound/1)
-  defp materialize_arguments(arguments, :down), do: Enum.map(arguments, &lower_bound/1)
-
-  defp are_arguments_dynamic?(arguments), do: Enum.any?(arguments, &match?(%{dynamic: _}, &1))
+  defp any_dynamic?(arguments), do: Enum.any?(arguments, &match?(%{dynamic: _}, &1))
 
   defp fun_normalize_both(fun_static, fun_dynamic, arity) do
     case fun_normalize(fun_static, arity, :static) do

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

@@ -765,8 +765,7 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun([integer()], none()), [integer()]) == {:ok, none()}
       assert fun_apply(fun([integer()], term()), [integer()]) == {:ok, term()}
 
-      # Dynamic return and dynamic args
-      assert fun_apply(fun([integer()], dynamic()), [integer()]) == {:ok, dynamic()}
+      # Dynamic args
       assert fun_apply(fun([term()], term()), [dynamic()]) == {:ok, term()}
 
       # Arity mismatches
@@ -781,13 +780,13 @@ defmodule Module.Types.DescrTest do
       # Function intersection with unions and dynamic return
       fun2 =
         intersection(
-          fun([union(integer(), atom())], dynamic()),
+          fun([union(integer(), atom())], term()),
           fun([union(integer(), pid())], atom())
         )
 
-      assert fun_apply(fun2, [integer()]) == {:ok, dynamic(atom())}
-      assert fun_apply(fun2, [atom()]) == {:ok, dynamic()}
-      assert fun_apply(fun2, [pid()]) |> elem(1) |> equal?(atom())
+      assert fun_apply(fun2, [integer()]) == {:ok, atom()}
+      assert fun_apply(fun2, [atom()]) == {:ok, term()}
+      assert fun_apply(fun2, [pid()]) == {:ok, atom()}
 
       # Function intersection with same domain, different codomains
       assert fun([integer()], term())
@@ -799,25 +798,6 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun3, [atom([:ok])]) == {:ok, none()}
     end
 
-    test "static with dynamic signature" do
-      assert fun_apply(fun([dynamic()], term()), [dynamic()]) == {:ok, term()}
-
-      assert fun_apply(fun([dynamic()], integer()), [dynamic()])
-             |> elem(1)
-             |> equal?(integer())
-
-      assert fun_apply(fun([dynamic(), atom()], float()), [dynamic(), atom()])
-             |> elem(1)
-             |> equal?(float())
-
-      fun = fun([dynamic(integer())], atom())
-      assert fun_apply(fun, [dynamic(integer())]) |> elem(1) |> equal?(atom())
-      # TODO: This should work
-      assert fun_apply(fun, [dynamic(number())]) == :badarg
-      assert fun_apply(fun, [integer()]) == :badarg
-      assert fun_apply(fun, [float()]) == :badarg
-    end
-
     defp dynamic_fun(args, return), do: dynamic(fun(args, return))
 
     test "dynamic" do
@@ -1712,6 +1692,9 @@ defmodule Module.Types.DescrTest do
       assert fun([integer(), float()], boolean()) |> to_quoted_string() ==
                "(integer(), float() -> boolean())"
 
+      assert fun([integer(), float()], dynamic()) |> to_quoted_string() ==
+               "dynamic((integer(), float() -> term()))"
+
       assert fun([integer()], boolean())
              |> union(fun([float()], boolean()))
              |> to_quoted_string() ==