Add isAsyncFunction

[ilxqx]

I think it is possible to add isAsyncFunction to determine whether the input value is a true asynchronous function (i.e., a function defined with the async keyword, excluding functions that return a Promise). The pseudocode is as follows:

function isAsyncFunction(fn: unknown) {
  // Firstly, check whether it is a function.
  if (typeof fn !== 'function') return false;
  
  // Check if the string representation of the function contains "async"
  const fnStr = fn.toString();
  
  // Check the characteristics of a function to determine if it is an async function
  return (
    // Check function declaration
    fnStr.startsWith('async ') ||
    // Check the AsyncFunction constructor
    Object.prototype.toString.call(fn) === '[object AsyncFunction]' ||
    // Check prototype chain
    fn.constructor.name === 'AsyncFunction'
  );
}

[ilxqx]

If you think it's feasible, I will submit a Pull Request.

[aleclarson]

Hey @ilxqx, good to hear from you. 😄

Looking at a popular type-checking library, it appears we can keep it as simple as:

import { isTagged } from 'radashi'

export function isAsyncFunction(value) {
  return isTagged(value, '[object AsyncFunction]')
}

What's unfortunate is I don't think TypeScript can reliably differentiate an async function from a promise-returning function, and there's no way to detect the latter at runtime. I don't see a use case where you would intentionally treat the two differently, so I don't know if isAsyncFunction would be particularly useful.

I think the best practice is to call the function and type-check its result.

let result = options.getFoo()
if (isPromise(result)) {
  return result.then(processFoo)
}
return processFoo(result)

If you have any insight on how isAsyncFunction could come in handy, I'd be glad to hear it. 👍

[DrSensor]

there is a more elegant way to do it

const AsyncFunction = async function () {}.constructor;

fn instanceof AsyncFunction // true

this trick also works on GeneratorFunction and AsyncGeneratorFunction

[ilxqx]

Hmm~~ Indeed, isAsyncFunction isn't all that useful. What might be more necessary is handling the results more reliably. Perhaps we should add a method invokeMaybeAsyncFn to reduce boilerplate code:

/**
 * Options for invoking a maybe async function
 */
export interface AsyncFnInvocationOptions<R> {
  /**
   * The function to invoke before the main function
   */
  beforeInvoke?: Handler;
  /**
   * The function to invoke on success
   */
  onSuccess?: Consumer<R>;
  /**
   * The function to invoke after the main function
   */
  onFinally?: Handler;
}

/**
 * Invoke a maybe async function
 *
 * @param fn - The function
 * @param options - The options
 * @param options.beforeInvoke - The function to invoke before the main function
 * @param options.onSuccess - The function to invoke on success
 * @param options.onFinally - The function to invoke after the main function
 * @param args - The arguments
 * @returns - The result
 */
export async function invokeMaybeAsyncFn<A extends any[], R>(
  fn: GenericFunction<A, MaybePromise<R>>,
  {
    beforeInvoke,
    onSuccess,
    onFinally,
  }: AsyncFnInvocationOptions<R>,
  ...args: A
) {
  const returned = fn(...args);

  if (returned instanceof Promise) {
    try {
      beforeInvoke?.();
      const result = await returned;
      onSuccess?.(result);
      return result;
    } finally {
      onFinally?.();
    }
  } else {
    return returned;
  }
}