RFC: function coroutine.finally(thread, callback)

[jkelaty-rbx]

Rendered

[MagmaBurnsV]

Would it be possible to instead return a status string detailing if the thread finished normally/failed/was cancelled, instead of a boolean? Or is this information lost after the thread is dead?

Because right now it's essentially impossible to differentiate between a closed thread and a thread that errored with the message "coroutine was closed".

[MagmaBurnsV]

It might be better to just error if the thread is already dead, since this behavior might lead to subtle bugs where you didn't expect the callback to run on the same thread.

You can still get this functionality back by checking the coroutine status and running the function inline, after all.

[MagmaBurnsV]

Can the callbacks yield? I assume not since other callbacks have to also run synchronously.

[Cooldude2606]

Overall I find this well written and a useful language level feature. However, silencing errors would be a deal breaker for me because it hinders not only debugging but also the detection of issues. For example, if most finally callbacks perform clean up actions then their failure may not introduce logical errors but rather memory leaks; which would be challenging to identify then trace back to the callback.

Propagating the error to the caller of resume or close would be preferable, which can be pcalled at that point if desired.

Although an alternative of replacing the status and message provided to proceeding callbackss could be a consideration. This would be similar to xpcall recalling the handler with its own error if the handler errors. But this would remove the ability to inspect the callstack through a custom xpcall error handler.

[bradsharp]

If finally provided the values that are still on the stack of the given thread it would allow you to implement await.

local function await(thread)
    local result = nil
    coroutine.finally(thread, function (...)
        result = table.pack(...)
    end)
    if not result then
        -- yield until the other thread has finished
        local current = coroutine.running()
        coroutine.finally(thread, function ()
            coroutine.resume(current)
        end)
        coroutine.yield()
    end
    local success = result[1]
    if not success then
        error(result[2])
    end
    return table.unpack(result, 2)
end

I don't think this needs to be perfect - the guarantee can be "whatever is left on the stack". A library can handle cases where the stack is later cleared by caching the result.

[bradsharp]

Is the callback allowed to yield? My initial reaction is no and we could always allow it later if we think it's okay.

[alicesaidhi]

i think it'd be more ideal instead of returning a boolean, it'd return a string literal between "error", "finished", "cancelled"