If I remember correctly both :ok idioms compile to the same bytecode and this has been true for a while now. Can’t remember since which OTP version though.

It’s the tuple creation that I’m concerned about. Sure, it’s cheap, but it’s not zero. Similarly, when I only care about what the shape of the {:ok, value} result is, I do this:

case something() do
  {:ok, value} -> # do something interesting with value
  error -> error
end

If the code generation for {:ok, value} -> {:ok, value} now avoids the creation of the second tuple (because it’s recognized as a duplicate), then the optimization is unnecessary. If it doesn’t, then I’d rather stick with the existing pattern, because I do have such things in tight loops where tuple creation might not be ideal

The opposite case of the error -> error shape above isn’t always possible:

case something() do
  {:ok, %{}} = ok -> ok # or {:ok, %{} = value} -> {:ok, value}
  {:ok, _} -> {:error, "Invalid return"}
  error -> error
end

Just to chime in: when this level of optimization is what you need, you might check out a different language or use something like rustler. After all: the mass result of this nano-optimization is thousand times gone as soon as you do something else slightly off.