I found that some code in the source code like `Promise.reject(),Promise.resolve()` seems redundant

[ckvv]

source code

  /**
   * @param {Object} context
   * @return {Promise}
   * @api public
   */

  return function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }

This still works well

      return function (context, next) {
        // last called middleware #
        let index = -1
        return disctxtch(0)

        function disctxtch(i) {
            if (i <= index) throw 'next() called multiple times';
            index = i
            let fn = middleware[i]
            if (i === middleware.length) fn = next
            if (!fn) return ;
            try {
                return fn(context, disctxtch.bind(null, i + 1));
            } catch (err) {
                throw err
            }
        }
    }

For what purpose? Can you explain?

[jonathanong]

because we always want to return a promise so that there are consistent types