Fewer ok

Author: josevalim

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

@@ -308,7 +308,8 @@ defmodule Module.Types.Expr do
         Of.map_fetch(expr, type, key_or_fun, stack, context)
       else
         {mods, context} = Of.remote(type, key_or_fun, 0, [:dot], expr, meta, stack, context)
-        apply_many(mods, key_or_fun, [], expr, stack, context)
+        {type, context} = apply_many(mods, key_or_fun, [], expr, stack, context)
+        {:ok, type, context}
       end
     end
   end
@@ -318,7 +319,8 @@ defmodule Module.Types.Expr do
     with {:ok, remote_type, context} <- of_expr(remote, stack, context),
          {:ok, args_types, context} <- map_reduce_ok(args, context, &of_expr(&1, stack, &2)) do
       {mods, context} = Of.remote(remote_type, name, length(args), expr, meta, stack, context)
-      apply_many(mods, name, args_types, expr, stack, context)
+      {type, context} = apply_many(mods, name, args_types, expr, stack, context)
+      {:ok, type, context}
     end
   end
 
@@ -464,20 +466,20 @@ defmodule Module.Types.Expr do
   defp error_type(), do: dynamic()
 
   defp apply_many([], _function, _args_types, _expr, _stack, context) do
-    {:ok, dynamic(), context}
+    {dynamic(), context}
   end
 
   defp apply_many([mod], function, args_types, expr, stack, context) do
     Of.apply(mod, function, args_types, expr, stack, context)
   end
 
   defp apply_many(mods, function, args_types, expr, stack, context) do
-    with {:ok, returns, context} <-
-           map_reduce_ok(mods, context, fn mod, context ->
-             Of.apply(mod, function, args_types, expr, stack, context)
-           end) do
-      {:ok, Enum.reduce(returns, &union/2), context}
-    end
+    {returns, context} =
+      Enum.map_reduce(mods, context, fn mod, context ->
+        Of.apply(mod, function, args_types, expr, stack, context)
+      end)
+
+    {Enum.reduce(returns, &union/2), context}
   end
 
   defp of_clauses(clauses, stack, context) do

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

@@ -336,10 +336,10 @@ defmodule Module.Types.Of do
       when is_integer(index) do
     case tuple_fetch(type, index - 1) do
       {_optional?, value_type} ->
-        {:ok, value_type, context}
+        {value_type, context}
 
       reason ->
-        {:ok, dynamic(), error({reason, expr, type, index - 1, context}, meta, stack, context)}
+        {dynamic(), error({reason, expr, type, index - 1, context}, meta, stack, context)}
     end
   end
 
@@ -351,24 +351,24 @@ defmodule Module.Types.Of do
       match?({false, _}, map_fetch(left, :__struct__)) or
           match?({false, _}, map_fetch(right, :__struct__)) ->
         warning = {:struct_comparison, expr, context}
-        {:ok, result, error(warning, elem(expr, 1), stack, context)}
+        {result, error(warning, elem(expr, 1), stack, context)}
 
       number_type?(left) and number_type?(right) ->
-        {:ok, result, context}
+        {result, context}
 
       disjoint?(left, right) ->
         warning = {:mismatched_comparison, expr, context}
-        {:ok, result, error(warning, elem(expr, 1), stack, context)}
+        {result, error(warning, elem(expr, 1), stack, context)}
 
       true ->
-        {:ok, result, context}
+        {result, context}
     end
   end
 
   def apply(mod, name, args, expr, stack, context) do
     case :elixir_rewrite.inline(mod, name, length(args)) do
       {mod, name} -> apply(mod, name, args, expr, stack, context)
-      false -> {:ok, dynamic(), context}
+      false -> {dynamic(), context}
     end
   end
 

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

@@ -672,7 +672,8 @@ defmodule Module.Types.Pattern do
       when is_atom(function) do
     with {:ok, args_type, context} <-
            map_reduce_ok(args, context, &of_guard(&1, dynamic(), expr, stack, &2)) do
-      Of.apply(:erlang, function, args_type, expr, stack, context)
+      {type, context} = Of.apply(:erlang, function, args_type, expr, stack, context)
+      {:ok, type, context}
     end
   end