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.

[lpil]

Sorry, I asked for use cases rather than abstract code the could be implemented with the feature 🙏 The purpose is to understand the motivation for the addition.

[halostatue]

That's not abstract code. That is shipping code in pontil, and the TS at the top is what I was replacing by wrapping Promise.prototype.finally. That's my use case. It makes it possible to write Gleam-equivalent code to try { … } finally { … } without further FFI.