fix: improve type specificity with overloads

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: skipped
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/nullary-strided1d-dispatch-factory/docs/types/index.d.ts

@@ -16,6 +16,8 @@
 * limitations under the License.
 */
 
+/* eslint-disable @typescript-eslint/prefer-function-type */
+
 // TypeScript Version: 4.1
 
 /// <reference types="@stdlib/types"/>
@@ -114,31 +116,47 @@ type NullaryWithFiveAdditionalArrays<T, U, V, W, X, Y> = ( arrays: [ typedndarra
 * @param options - function options
 * @returns result
 */
-type NullaryWithAnyAdditionalArrays<T, U> = ( arrays: [ typedndarray<T>, ...Array<typedndarray<U>> ], options?: unknown ) => typedndarray<T>;
+type NullaryWithAdditionalArrays<T, U> = ( arrays: [ typedndarray<T>, ...Array<typedndarray<U>> ], options?: unknown ) => typedndarray<T>;
 
 /**
-* Strided function.
-*
-* @param arrays - input ndarrays
-* @param options - function options
-* @returns result
+* Base dispatch table.
+*/
+interface BaseDispatchTable1<T> {
+	/**
+	* Default strided function.
+	*/
+	default: Nullary<T>;
+}
+
+/**
+* Dispatch table.
 */
-type NullaryWithAdditionalArrays<T, U, V, W, X, Y> = NullaryWithOneAdditionalArray<T, U> | NullaryWithTwoAdditionalArrays<T, U, V> | NullaryWithThreeAdditionalArrays<T, U, V, W> | NullaryWithFourAdditionalArrays<T, U, V, W, X> | NullaryWithFiveAdditionalArrays<T, U, V, W, X, Y> | NullaryWithAnyAdditionalArrays<T, U>;
+interface DispatchTable1<T> extends BaseDispatchTable1<T> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<Nullary<T>>;
+}
 
 /**
 * Base dispatch table.
 */
-interface BaseDispatchTable<T, U, V, W, X, Y> {
+interface BaseDispatchTable2<T, U> {
 	/**
 	* Default strided function.
 	*/
-	default: Nullary<T> | NullaryWithAdditionalArrays<T, U, V, W, X, Y>;
+	default: NullaryWithOneAdditionalArray<T, U>;
 }
 
 /**
 * Dispatch table.
 */
-interface DispatchTable<T, U, V, W, X, Y> extends BaseDispatchTable<T, U, V, W, X, Y> {
+interface DispatchTable2<T, U> extends BaseDispatchTable2<T, U> {
 	/**
 	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
 	*/
@@ -147,20 +165,159 @@ interface DispatchTable<T, U, V, W, X, Y> extends BaseDispatchTable<T, U, V, W,
 	/**
 	* List of strided functions which are specific to specialized output ndarray argument signatures.
 	*/
-	fcns: ArrayLike<Nullary<T> | NullaryWithAdditionalArrays<T, U, V, W, X, Y>>;
+	fcns: ArrayLike<NullaryWithOneAdditionalArray<T, U>>;
 }
 
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable3<T, U, V> {
+	/**
+	* Default strided function.
+	*/
+	default: NullaryWithTwoAdditionalArrays<T, U, V>;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable3<T, U, V> extends BaseDispatchTable3<T, U, V> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<NullaryWithTwoAdditionalArrays<T, U, V>>;
+}
+
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable4<T, U, V, W> {
+	/**
+	* Default strided function.
+	*/
+	default: NullaryWithThreeAdditionalArrays<T, U, V, W>;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable4<T, U, V, W> extends BaseDispatchTable4<T, U, V, W> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<NullaryWithThreeAdditionalArrays<T, U, V, W>>;
+}
+
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable5<T, U, V, W, X> {
+	/**
+	* Default strided function.
+	*/
+	default: NullaryWithFourAdditionalArrays<T, U, V, W, X>;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable5<T, U, V, W, X> extends BaseDispatchTable5<T, U, V, W, X> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<NullaryWithFourAdditionalArrays<T, U, V, W, X>>;
+}
+
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable6<T, U, V, W, X, Y> {
+	/**
+	* Default strided function.
+	*/
+	default: NullaryWithFiveAdditionalArrays<T, U, V, W, X, Y>;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable6<T, U, V, W, X, Y> extends BaseDispatchTable6<T, U, V, W, X, Y> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<NullaryWithFiveAdditionalArrays<T, U, V, W, X, Y>>;
+}
+
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable<T, U> {
+	/**
+	* Default strided function.
+	*/
+	default: Nullary<T> | NullaryWithAdditionalArrays<T, U>;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable<T, U> extends BaseDispatchTable<T, U> {
+	/**
+	* One-dimensional list of ndarray data types describing specialized output ndarray argument signatures.
+	*/
+	types: ArrayLike<DataType>;
+
+	/**
+	* List of strided functions which are specific to specialized output ndarray argument signatures.
+	*/
+	fcns: ArrayLike<Nullary<T> | NullaryWithAdditionalArrays<T, U>>;
+}
 
 /**
 * Interface for applying an operation to an ndarray.
 */
-interface NullaryFunction<T, U, Z> {
+interface NullaryFunction1<T> {
 	/**
 	* Applies a strided function and assign results to a provided output ndarray.
 	*
 	* @param out - output ndarray
 	* @param options - function options
 	* @returns output ndarray
+	*/
+	<Out extends OutputArray<T> = OutputArray<T>>( out: Out, options?: BaseOptions ): Out;
+}
+
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction2<T, U> {
+	/**
+	* Applies a strided function and assigns results to a provided output ndarray.
+	*
+	* @param out - output ndarray
+	* @param x1 - first additional ndarray argument
+	* @param options - function options
+	* @returns output ndarray
 	*
 	* @example
 	* var base = require( '@stdlib/blas/ext/base/ndarray/gsorthp' );
@@ -180,7 +337,7 @@ interface NullaryFunction<T, U, Z> {
 	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
 	*
 	* var order = scalar2ndarray( 1.0, {
-	*     'dtype': 'generic'
+	*      'dtype': 'generic'
 	* });
 	*
 	* var out = sorthp( x, order );
@@ -189,13 +346,87 @@ interface NullaryFunction<T, U, Z> {
 	* var bool = ( out === x );
 	* // returns true
 	*/
-	<Out extends OutputArray<T> = OutputArray<T>>( out: Out, options?: BaseOptions ): Out;
+	<Out extends OutputArray<T> = OutputArray<T>, X1 extends InputArray<U> = InputArray<U>>( out: Out, x1: X1, options?: BaseOptions ): Out;
+}
+
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction3<T, U, V> {
+	/**
+	* Applies a strided function and assigns results to a provided output ndarray.
+	*
+	* @param out - output ndarray
+	* @param x1 - first additional ndarray argument
+	* @param x2 - second additional ndarray argument
+	* @param options - function options
+	* @returns output ndarray
+	*/
+	<Out extends OutputArray<T> = OutputArray<T>, X1 extends InputArray<U> = InputArray<U>, X2 extends InputArray<V> = InputArray<V>>( out: Out, x1: X1, x2: X2, options?: BaseOptions ): Out;
+}
+
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction4<T, U, V, W> {
+	/**
+	* Applies a strided function and assigns results to a provided output ndarray.
+	*
+	* @param out - output ndarray
+	* @param x1 - first additional ndarray argument
+	* @param x2 - second additional ndarray argument
+	* @param x3 - third additional ndarray argument
+	* @param options - function options
+	* @returns output ndarray
+	*/
+	<Out extends OutputArray<T> = OutputArray<T>, X1 extends InputArray<U> = InputArray<U>, X2 extends InputArray<V> = InputArray<V>, X3 extends InputArray<W> = InputArray<W>>( out: Out, x1: X1, x2: X2, x3: X3, options?: BaseOptions ): Out;
+}
+
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction5<T, U, V, W, X> {
+	/**
+	* Applies a strided function and assigns results to a provided output ndarray.
+	*
+	* @param out - output ndarray
+	* @param x1 - first additional ndarray argument
+	* @param x2 - second additional ndarray argument
+	* @param x3 - third additional ndarray argument
+	* @param x4 - fourth additional ndarray argument
+	* @param options - function options
+	* @returns output ndarray
+	*/
+	<Out extends OutputArray<T> = OutputArray<T>, X1 extends InputArray<U> = InputArray<U>, X2 extends InputArray<V> = InputArray<V>, X3 extends InputArray<W> = InputArray<W>, X4 extends InputArray<X> = InputArray<X>>( out: Out, x1: X1, x2: X2, x3: X3, x4: X4, options?: BaseOptions ): Out;
+}
 
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction6<T, U, V, W, X, Y> {
+	/**
+	* Applies a strided function and assigns results to a provided output ndarray.
+	*
+	* @param out - output ndarray
+	* @param x1 - first additional ndarray argument
+	* @param x2 - second additional ndarray argument
+	* @param x3 - third additional ndarray argument
+	* @param x4 - fourth additional ndarray argument
+	* @param x5 - fifth additional ndarray argument
+	* @param options - function options
+	* @returns output ndarray
+	*/
+	<Out extends OutputArray<T> = OutputArray<T>, X1 extends InputArray<U> = InputArray<U>, X2 extends InputArray<V> = InputArray<V>, X3 extends InputArray<W> = InputArray<W>, X4 extends InputArray<X> = InputArray<X>, X5 extends InputArray<Y> = InputArray<Y>>( out: Out, x1: X1, x2: X2, x3: X3, x4: X4, x5: X5, options?: BaseOptions ): Out;
+}
+
+/**
+* Interface for applying an operation to an ndarray.
+*/
+interface NullaryFunction<T, Z> {
 	/**
 	* Applies a strided function and assigns results to a provided output ndarray.
 	*
 	* @param out - output ndarray
-	* @param x - additional ndarray argument
 	* @param args - output ndarray, additional array arguments, and function options
 	* @returns output ndarray
 	*
@@ -226,7 +457,7 @@ interface NullaryFunction<T, U, Z> {
 	* var bool = ( out === x );
 	* // returns true
 	*/
-	<Out extends OutputArray<T> = OutputArray<T>>( out: Out, x: InputArray<U>, ...args: Array<InputArray<Z> | BaseOptions> ): Out;
+	<Out extends OutputArray<T> = OutputArray<T>>( out: Out, ...args: Array<InputArray<Z> | BaseOptions> ): Out;
 }
 
 /**
@@ -265,7 +496,19 @@ interface NullaryFunction<T, U, Z> {
 * var bool = ( out === x );
 * // returns true
 */
-declare function factory<T = unknown, U = unknown, V = unknown, W = unknown, X = unknown, Y = unknown>( table: DispatchTable<T, U, V, W, X, Y> | BaseDispatchTable<T, U, V, W, X, Y>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction<T, U, V | W | X | Y>;
+declare function factory<T = unknown>( table: DispatchTable1<T> | BaseDispatchTable1<T>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction1<T>;
+
+declare function factory<T = unknown, U = unknown>( table: DispatchTable2<T, U> | BaseDispatchTable2<T, U>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction2<T, U>;
+
+declare function factory<T = unknown, U = unknown, V = unknown>( table: DispatchTable3<T, U, V> | BaseDispatchTable3<T, U, V>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction3<T, U, V>;
+
+declare function factory<T = unknown, U = unknown, V = unknown, W = unknown>( table: DispatchTable4<T, U, V, W> | BaseDispatchTable4<T, U, V, W>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction4<T, U, V, W>;
+
+declare function factory<T = unknown, U = unknown, V = unknown, W = unknown, X = unknown>( table: DispatchTable5<T, U, V, W, X> | BaseDispatchTable5<T, U, V, W, X>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction5<T, U, V, W, X>;
+
+declare function factory<T = unknown, U = unknown, V = unknown, W = unknown, X = unknown, Y = unknown>( table: DispatchTable6<T, U, V, W, X, Y> | BaseDispatchTable6<T, U, V, W, X, Y>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction6<T, U, V, W, X, Y>;
+
+declare function factory<T = unknown, U = unknown>( table: DispatchTable<T, U> | BaseDispatchTable<T, U>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, options?: FactoryOptions ): NullaryFunction<T, U>;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/ndarray/base/nullary-strided1d-dispatch-factory/docs/types/test.ts

@@ -36,8 +36,8 @@ import factory = require( './index' );
 		'default': gsorthp
 	};
 
-	factory<unknown, number>( table, [ dtypes ], dtypes ); // $ExpectType NullaryFunction<unknown, number, unknown>
-	factory<unknown, number>( table, [ dtypes ], dtypes, {} ); // $ExpectType NullaryFunction<unknown, number, unknown>
+	factory<unknown, number>( table, [ dtypes ], dtypes ); // $ExpectType NullaryFunction2<unknown, number>
+	factory<unknown, number>( table, [ dtypes ], dtypes, {} ); // $ExpectType NullaryFunction2<unknown, number>
 }
 
 // The compiler throws an error if the function is provided a first argument which is not a dispatch table...