Distinct return type tuples with type narrowing

[13k]

It's a common pattern to have functions that return a result and an error and have the client code to check if the result is nil and assume the function returned an error, like this:

local function foo()
  if some_failure() then
    return nil, "error"
  else
    return "ok", nil
end

local res, err = foo()

if not res then
  error(err)
end

and it's also common to see this pattern being used with assert:

local res = assert(foo())

which will type-narrow res to T - ? (non-nil).

But the only way I (and several libraries I've seen) to annotate such a function would be:

--- @return string?, string?
local function foo() end

which means the return type is a combination (string, string) | (string, nil) | (nil, string) | (nil, nil), which is incorrect and will require type narrowing for every possible permutation.

do
  local res, err = foo()

  if not res then
    -- err: string? (`need-check-nil` warning)
    error(err:upper())
  end

  -- res: string
  print(res:upper())
end

do
  local res, err = foo()

  if err then
    -- err: string
    error(err:upper())
  end

  -- res: string? (`need-check-nil` warning)
  print(res:upper())
end

using overload doesn't work too:

--- always returns (nil, string)
--- @return string, nil
--- @overload fun(): (nil, string)
local function overload1()
  if #arg > 1 then
    return "ok", nil
  else
    -- return-type-mismatch
    return nil, "error"
  end
end

do
  -- s: nil, err: string
  local s, err = overload1()

  if not s then
    error(err:upper())
  end

  --- s: `unknown`
  print(s:upper())
end

--- always returns (string, nil)
--- @return nil, string
--- @overload fun(): (string, nil)
local function overload2()
  if #arg > 1 then
    -- return-type-mismatch
    return "ok", nil
  else
    return nil, "error"
  end
end

do
  -- s: string, err: nil
  local s, err = overload2()

  if not s then
    -- need-check-nil
    error(err:upper())
  end

  print(s:upper())
end

Is there any way to restrict the return type to (string, nil) | (nil, string) and have automatic type narrowing on either if not res or if err?

[CppCXY]

No, in all the languages I know, there is no way to narrow variable 'b' based on variable 'a'. Although I could implement it, it would significantly affect the performance for other that don't use this approach. I am not willing to greatly reduce performance just for a special preference in Lua.

I suggest you also check the err variable; this is reasonable in itself.

[13k]

I guess what I am asking is about tuples being actual types, like in Rust where (T, U) == (T, U) and (T, U) != (T, V).

It would formalize types where tuples are used such as return types, table.pack()/unpack(), select() and {...}, instead of having hacks and special cases for these cases.

I understand it would probably be a big change, but it's an idea.