promise.finally

[halostatue]

I can look at contributing this if it would be accepted, but there is no promise.finally that would map to Promise.finally.

This would allow translation of try/finally async/await functions.

[halostatue]

After some playing around, I think that the signature looks like:

fn finally(promise: Promise(a), on_finally: fn() -> Nil) -> Promise(a)

// or maybe
fn finally(promise: Promise(a), on_finally: fn() -> b) -> Promise(a)

and the implementation is:

export function promise_finally(promise, fn) {
  return promise.finally(fn);
}

This is a bit weird because the return value can matter:

Note: A throw (or returning a rejected promise) in the finally callback still rejects the returned promise. For example, both Promise.reject(3).finally(() => { throw 99; }) and Promise.reject(3).finally(() => Promise.reject(99)) reject the returned promise with the reason 99.

I'm writing it as above it in pontil 1.0 for my needs, but I'm not sure that it is the right solution for gleam_javascript.

[lpil]

Hello! What are some use cases for this functionality?

[halostatue]

So, basically:

async function group<T>(name: string, action: () => Promise<T>): Promise<T> {
  group_start(name)

  let result: T
  try {
    result = await action()
  } finally {
    group_end()
  }

  return result
}

// or with promises:
function group<T>(name: string, action() => Promise<T>): Promise<T> {
  group_start(name);

  return action().finally(group_end)
}

The non-promise version is easy in Gleam:

pub fn group(name name: String, do action: fn() -> a) -> a {
  group_start(name)
  let result = action()
  group_end()
  result
}

But we need an FFI on promise.finally for a promise version:

pub fn group_async(
  name name: String,
  do action: fn() -> Promise(a),
) -> Promise(a) {
  group_start(name)

  promise_finally(promise: action(), on_finally: group_end)
}

Anytime that there's resource cleanup or (in this case) bracketed logs, you need the equivalent of try/finally, and Promise.prototype.finally fills the bill without having to FFI every call.