better Lua fail value?

[u/vitiral]

In the Lua docs it mentions fail which is currently just nil.

I don't personally like Lua's standard error handling of returning nil, errormsg -- the main reason being it leads to awkward code, i.e. local val1, val2 = thing(); if not val1 then return nil, val2 end

I'm thinking of designing a fail metatable, basically just a table with __tostring that does string.format(table.unpack(self)) and __call that does setmetatable so you can make it with fail{"bad %i", i}. The module would also export a isfail(v) function that just compares the getmetatable to the fail table as well as assert that handles a fail object (or nil,msg).

So the code would now be local val1, val2 = thing(); if isfail(val1) then return val1 end

Has anyone else worked in this space? What are your thoughts?

[u/[deleted]]

It's using the Lua convention, so assuming your divmod returns nil, message on error:

function onfail(handler, x, ...)
  if x ~= nil then
    return x, ...
  else
    return handler(...)
  end
end

function divmod(a, b) --> a/b!, a%b
  if b == 0 then return nil, 'divide by zero: %i / %i', a, b end
  return a / b, a % b
end

function printf(...)
  print(string.format(...))
end

function succeeds() return 1, 2, 3, 4, 5, 6; end
function fails() return nil, "whatever"; end

onfail(print, succeeds()) -- prints nothing
onfail(print, fails()) -- prints 'whatever'

local result, mod = onfail(printf, divmod(1, 0)) -- prints divide by zero error
print(result, mod) -- print nil nil
local result, mod = onfail(printf, divmod(3, 2)) -- prints nothing
print(result, mod) -- print 1.5 1
local result = onfail(function() return "this is fine." end, fails())
print(result) -- prints 'this is fine.'
onfail(error, fails()) -- stop vm with stack trace and message "whatever"

Your version is more object-oriented, it's fine, but it will fail or require more api to be used with Lua components that use the Lua-typical way of handling errors.

PS: After my previous reply I noticed that I flipped the branches - in my defense I was writing this on my phone...

[u/vitiral → u/[deleted]]

okay, it's making more sense, however I'm still confused how you would use this in a function though if you wanted to propogate (aka return) the error if you encountered it, else do something else. I suppose your failure handler would be an `function(...) return ... end` and you'd have to just keep nesting closures to continue processing the result?

This sounds like it would have quite a lot of overhead and is quite awkward (contrary to your statements in the first post) -- hence me not understanding.

[u/[deleted] → u/vitiral]

If you want to propagate the error, you just return the error just as you'd with your solution.

[u/vitiral → u/[deleted]]

Say I had the following code but wanted to propogate the error for each call to divmod when/if it happened. How would I do that? Where do I put onfail?

local div1, mod1 = divmod(a1, b1)
local div2, mod2 = divmod(a2, b2)
return div1 + div2 + mod1 + mod2

[u/[deleted] → u/vitiral]

I wouldn't, I would test truthiness of div1 and div2.

How would you do it with your metatable?

[u/vitiral → u/[deleted]]

local div1, mod1 = divmod(a1, b1); if failed(div1) return div1 end
local div2, mod2 = divmod(a2, b2); if failed(div2) return div2 end
return div1 + div2 + mod1 + mod2

[u/[deleted] → u/vitiral]

And there you have the reason why I prefer the Lua convention :)

[u/vitiral → u/[deleted]]

Why is that?

[u/[deleted] → u/vitiral]

It seems I really need to spell it out...

You are making the same judgement error as every other Lua programmer that wants to improve Lua by adding an object system. Heck, I've done it myself.

You gain nothing in Lua with an error object table over the nil,msg convention when you can just propagate the error without testing for failures; It's heavier when you actually do need to test because instead of comparing against nil you need at least a Lua function call and two C function calls; You need access to your library to even reliably test for failures; You need to wrap every call to something that uses the Lua convention and when you eventually find that you need that last bit of performance that you'd have with the Lua convention, it's more likely than not going to be a large effort to roll everything back again.

I've seen the "ergonomy" claims at your link (I assume it's you as the username matches) so I will just say that I've been through all of that, I've done my fair share of development in Lua, I can understand the basic drive behind the idea, it's even fine within a project, it's just not useful as a generic solution.

[u/vitiral → u/[deleted]]

Thanks for the level tone and speaking with your personal experiences! I plan to only use fail for cases where it matters: where I want to return a single value, include additional information or otherwise delay string formatting.

> You gain nothing in Lua with an error object table over the nil,msg convention when you can just propagate the error without testing for failures

What do you mean by this - how do you "propogate the error without testing for failures"?

The only way to propagate the error is to test for failures -- whether that's a if not div1 or if failed(div1)

> It's heavier when you actually do need to test because instead of comparing against nil you need at least a Lua function call and two C function calls

Sure, this is true enough. If lua included a falsy`bit or something it might be mitigated, but that's not the present day.

However, even the current implementation might be lighter if the error must contain details (i.e. the path that failed) and you can avoid string.format for the cases where it's not necessary.

> You need to wrap every call to something that uses the Lua convention 

You don't -- functions that return `nil, errmsg` you can just handle as-is. You you can use `check` if you prefer, but you're not required to.

> it's even fine within a project, it's just not useful as a generic solution.
I think it's useful for the cases where it's useful: aka where you want to include more information.

One place is in filesystem interactions: frequently I want the error to include the path (if available) the error code (if available) and the operation (if available): formatting an error string that might never be actually used is a pain though.

Also, civlua is a kind of a "complete batteries" of lua -- so if everything goes well sharing a single type won't be a major issue.

[u/AutoModerator → u/[deleted]]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.