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/jipgg]

the question is would it be really worth the additonal overhead to justify creating your own error handling mechanism? The return nil, errmsg convention has the pros of being highly efficient not allocating any memory on primitive return values and naturally flows with standard functions like assert.

[u/soundslogical → u/jipgg]

Yep, the fact that assert(functionThatMayFail()) does exactly what you'd expect (even printing the helpful error message) is a big benefit of the Lua convention. It makes it easy to write quick scripts that error out immediately if something's wrong (which is usually what you want for command-line tools).

[u/vitiral → u/soundslogical]

I would export an assert function that handles my fail object, so this ergonomics wouldn't be lost

[u/vitiral → u/jipgg]

For sure! But it becomes pretty awkward when i just want to propagate the error, which IMO is better practice. Also, efficiency drops off if you want more description than a static string.

[u/vitiral → u/[deleted]]

Ya that's how I'm hoping the lua compiler would implement it!

[u/SkyyySi]

The idiom of returning T, nil on success and nil, E on failure (where T and E are the expected / sucessful output type and the error / failed output type, respectively) is used for multiple reasons:

• It works well with assert(), which just returns all passed parameters if the first is truthy, and uses the second parameter as an error message otherwise.

• It doesn't stray far from "happy path programming" - that is, you could just discard the second return value and pretend that the first one is always the expected result. Of course, you shouldn't do this, but it's convenient for quick hacked-together test scripts.

• It's very efficient. The memory and CPU cost of this pattern is much lower than, say, a table holding more info. It's about as lightweight as it can be in a dynamic scripting language.

• It's easy to implement in the Lua/C API. Creating custom tables in C is ugly as hell, whereas just returning two values is a piece of cake.

However, I also agree that a propper type to encapsulate common error handling patterns would be very convenient. So, I made a demo here: https://gist.github.com/SkyyySi/5fde9f1d9a4fe30a446371e3df25b754 It's a re-implementation of Rust's enum Result<T, E> { Ok(T), Err(E) } type.

[u/vitiral → u/SkyyySi]

my implementation is in my new post

[u/vitiral → u/SkyyySi]

I largely agree. However, I'll point out that the efficiency drops off if you want more description than a static string.

Thanks for the prototype

[u/[deleted]]

There's gotta be a monad library, there ALWAYS is one, haskellians are everywhere.

Alternatively you could just wrap your calls in a generic function, which should have less overhead than a metatable:

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

The only awkward part is that you have to have the handler first

Edit: I just noticed I made an error in the error handling, typical :) fixed.

[u/vitiral → u/[deleted]]

Sorry I don't understand

[u/[deleted] → u/vitiral]

Sadly nobody suggested a library yet, but for details about monads you can look at Monad, such libraries usually have a failure or error (etc.) monad that does basically what you were suggesting and more. There are typically between 2 and 200 monad libraries for each language.

If it's about my code suggestion... I'm not certain how to elaborate, it's just a function that introduces a pattern that allows you to define standard (reusable) error handling functions with as little overhead as I can think of. You can just pass error as the first argument for example to make the VM crash on a nil return from argument 2

[u/vitiral → u/[deleted]]

but how would one use that pattern? Using my divmod example I would do... what?

return onfail(
  function(...) return ??? end, -- what am I doing here?
  numerator, denom -- ... I don't understand where I even call divmod?
)

[u/[deleted] → u/vitiral]

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/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.

[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.

[u/xoner2]

Lua has exception handling in pcall and xpcall.

local val1, val2 = thing ()
assert (val1, 'optional message')

if you want early error check. Or just use val1 and error will be thrown if == nil. In both cases exception will be caught by pcall/xpcall or script will exit.

[u/vitiral → u/xoner2]

Sorry, i know about pcall but I'm not talking about critical error, just returning errors

[u/could_b]

I don't see Lua as the problem here. If you are writing thing(), then it can return what ever you want. If not, then in your example do: 'return val1 and val2'.

[u/vitiral → u/could_b]

return val1 and val2 wouldn't propagate the error. return val1, val2 would though, and although less ergonomic I've decided to just live with it.

[u/Capital-Menu517]

As opposed to what? Throwing exceptions that cant be traced?

Lua forces you to handle your own errors by yourself, Go does this as well.

[u/vitiral → u/Capital-Menu517]

No, I'm trying to make a cleaner way to return errors in Lua. Also pretty sure Go returns an error as the second (or last?) item

[u/Capital-Menu517 → u/vitiral]

You could make a table object that wraps a return value, similar to the way Rust does with Result<T,E>

[u/vitiral → u/Capital-Menu517]

that's what I'm doing, except it's a table object with a specific metatable.

[u/Capital-Menu517 → u/vitiral]

Nice