chore: clean-up

---
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: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - 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/array/base/map/benchmark/benchmark.assign.js

@@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var uniform = require( '@stdlib/random/array/uniform' );
-var identity = require( '@stdlib/math/base/special/identity' );
+var identity = require( '@stdlib/number/float64/base/identity' );
 var zeros = require( '@stdlib/array/base/zeros' );
 var pkg = require( './../package.json' ).name;
 var map = require( './../lib' ).assign;

lib/node_modules/@stdlib/array/base/map/benchmark/benchmark.js

@@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var uniform = require( '@stdlib/random/array/uniform' );
-var identity = require( '@stdlib/math/base/special/identity' );
+var identity = require( '@stdlib/number/float64/base/identity' );
 var pkg = require( './../package.json' ).name;
 var map = require( './../lib' );
 

lib/node_modules/@stdlib/array/base/map/docs/repl.txt

@@ -9,9 +9,9 @@
     - index: current array element index.
     - arr: the input array.
 
-    If provided an array-like object having a `map` method, the function
-    defers execution to that method and assumes that the method has the
-    following signature:
+    If provided an array-like object having a `map` method, the function defers
+    execution to that method and assumes that the method has the following
+    signature:
 
         x.map( fcn, thisArg )
 

lib/node_modules/@stdlib/array/base/map/docs/types/index.d.ts

@@ -20,22 +20,51 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { Collection, AccessorArrayLike } from '@stdlib/types/array';
+import { Collection, AccessorArrayLike, TypedArray } from '@stdlib/types/array';
+
+/**
+* Input array.
+*/
+type InputArray<T> = Collection<T> | AccessorArrayLike<T>;
+
+/**
+* Output array.
+*/
+type OutputArray<T> = Collection<T> | AccessorArrayLike<T>;
+
+/**
+* Interface for an object having a `map` method.
+*/
+interface ObjectWithMap<T> {
+	/**
+	* Invokes a callback for each element in an array and assigns results to a new output array.
+	*
+	* @param clbk - callback to apply
+	* @param thisArg - callback execution context
+	* @returns output array
+	*/
+	map<V>( clbk: Callback<T, InputArray<T>, V, unknown>, thisArg?: unknown ): ObjectWithMap<V>;
+}
+
+/**
+* An array having a `map` method.
+*/
+type ArrayWithMap<T> = InputArray<T> & ObjectWithMap<T>;
 
 /**
 * Callback invoked for each array element.
 *
 * @returns result
 */
-type Nullary<U, V> = ( this: V ) => U;
+type Nullary<V, ThisArg> = ( this: ThisArg ) => V;
 
 /**
 * Callback invoked for each array element.
 *
 * @param value - current array element
 * @returns result
 */
-type Unary<T, U, V> = ( this: V, value: T ) => U;
+type Unary<T, V, ThisArg> = ( this: ThisArg, value: T ) => V;
 
 /**
 * Callback invoked for each array element.
@@ -44,7 +73,7 @@ type Unary<T, U, V> = ( this: V, value: T ) => U;
 * @param index - current array element index
 * @returns result
 */
-type Binary<T, U, V> = ( this: V, value: T, index: number ) => U;
+type Binary<T, V, ThisArg> = ( this: ThisArg, value: T, index: number ) => V;
 
 /**
 * Callback invoked for each array element.
@@ -54,7 +83,7 @@ type Binary<T, U, V> = ( this: V, value: T, index: number ) => U;
 * @param arr - input array
 * @returns result
 */
-type Ternary<T, U, V> = ( this: V, value: T, index: number, arr: Collection<T> | AccessorArrayLike<T> ) => U;
+type Ternary<T, U, V, ThisArg> = ( this: ThisArg, value: T, index: number, arr: U ) => V;
 
 /**
 * Callback invoked for each array element.
@@ -64,7 +93,7 @@ type Ternary<T, U, V> = ( this: V, value: T, index: number, arr: Collection<T> |
 * @param arr - input array
 * @returns result
 */
-type Callback<T, U, V> = Nullary<U, V> | Unary<T, U, V> | Binary<T, U, V> | Ternary<T, U, V>;
+type Callback<T, U, V, ThisArg> = Nullary<V, ThisArg> | Unary<T, V, ThisArg> | Binary<T, V, ThisArg> | Ternary<T, U, V, ThisArg>;
 
 /**
 * Interface describing the main export.
@@ -79,23 +108,51 @@ interface Routine {
 	* @returns output array
 	*
 	* @example
-	* var toAccessorArray = require( '@stdlib/array/to-accessor-array' );
 	* var ones = require( '@stdlib/array/base/ones' );
 	*
 	* function scale( v ) {
-	*     return v * 10.0;
+	*     return v * 10;
 	* }
 	*
 	* var x = ones( 4 );
-	* var y = map( toAccessorArray( x ), scale );
-	* // returns [ 10.0, 10.0, 10.0, 10.0 ]
+	* // returns [ 0, 0, 0, 0 ]
+	*
+	* var y = map( x, scale );
+	* // returns [ 10, 10, 10, 10 ]
+	*/
+	<T = unknown, U extends Array<T> = Array<T>, V = unknown, W extends Array<V> = Array<V>, ThisArg = unknown>( x: U, fcn: Callback<T, U, V, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, V, ThisArg>> ): W;
+
+	/**
+	* Applies a callback function to elements in an input array and assigns results to elements in a new output array.
+	*
+	* @param x - input array object
+	* @param fcn - callback function
+	* @param thisArg - callback execution context
+	* @returns output array
+	*
+	* @example
+	* var ones = require( '@stdlib/array/ones' );
+	*
+	* function scale( v ) {
+	*     return v * 10;
+	* }
+	*
+	* var x = ones( 4, 'int32' );
+	* // returns <Int32Array>[ 0, 0, 0, 0 ]
+	*
+	* var y = map( x, scale );
+	* // returns <Int32Array>[ 10, 10, 10, 10 ]
 	*/
-	<T = unknown, U = unknown, V = unknown>( x: AccessorArrayLike<T>, fcn: Callback<T, U, V>, thisArg?: ThisParameterType<Callback<T, U, V>> ): AccessorArrayLike<U>;
+	<T = unknown, U extends TypedArray = TypedArray, V = unknown, ThisArg = unknown>( x: U, fcn: Callback<T, U, V, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, V, ThisArg>> ): U;
 
 	/**
 	* Applies a callback function to elements in an input array and assigns results to elements in a new output array.
 	*
-	* @param x - input array
+	* ## Notes
+	*
+	* -   We assume that an input array having a `map` method returns an array of the same class, and, thus, the output array should also have a `map` method.
+	*
+	* @param x - input array object
 	* @param fcn - callback function
 	* @param thisArg - callback execution context
 	* @returns output array
@@ -104,52 +161,55 @@ interface Routine {
 	* var ones = require( '@stdlib/array/base/ones' );
 	*
 	* function scale( v ) {
-	*     return v * 10.0;
+	*     return v * 10;
 	* }
 	*
 	* var x = ones( 4 );
+	* // returns [ 0, 0, 0, 0 ]
+	*
 	* var y = map( x, scale );
-	* // returns [ 10.0, 10.0, 10.0, 10.0 ]
+	* // returns [ 10, 10, 10, 10 ]
 	*/
-	<T = unknown, U = unknown, V = unknown>( x: Collection<T>, fcn: Callback<T, U, V>, thisArg?: ThisParameterType<Callback<T, U, V>> ): Collection<U>;
+	<T = unknown, U extends ArrayWithMap<T> = ArrayWithMap<T>, V = unknown, W extends ArrayWithMap<V> = ArrayWithMap<V>, ThisArg = unknown>( x: U, fcn: Callback<T, U, V, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, V, ThisArg>> ): W;
 
 	/**
-	* Applies a callback function to elements in an input array and assigns results to elements in an output array.
+	* Applies a callback function to elements in an input array and assigns results to elements in a new output array.
+	*
+	* ## Notes
+	*
+	* -   When an input array does not have a `map` method, we always return a new "generic" array.
 	*
 	* @param x - input array object
-	* @param y - output array object
-	* @param stride - stride length for output array
-	* @param offset - starting index for output array
 	* @param fcn - callback function
 	* @param thisArg - callback execution context
-	* @returns output array object
+	* @returns output array
 	*
 	* @example
 	* var toAccessorArray = require( '@stdlib/array/to-accessor-array' );
 	* var ones = require( '@stdlib/array/base/ones' );
-	* var zeros = require( '@stdlib/array/base/zeros' );
 	*
 	* function scale( v ) {
 	*     return v * 10;
 	* }
+	*
 	* var x = ones( 4 );
-	* var y = zeros( x.length );
+	* // returns [ 0, 0, 0, 0 ]
 	*
-	* var out = map.assign( toAccessorArray( x ), toAccessorArray( y ), 1, 0 scale );
-	* // y => [ 10, 10, 10, 10 ]
+	* var y = map( toAccessorArray( x ), scale );
+	* // returns [ 10, 10, 10, 10 ]
 	*/
-	assign<T = unknown, U = unknown, V = unknown>( x: AccessorArrayLike<T>, y: AccessorArrayLike<U>, stride: number, offset: number, fcn: Callback<T, U, V>, thisArg?: ThisParameterType<Callback<T, U, V>> ): AccessorArrayLike<U>;
+	<T = unknown, U extends InputArray<T> = InputArray<T>, V = unknown, ThisArg = unknown>( x: U, fcn: Callback<T, U, V, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, V, ThisArg>> ): Array<V>;
 
 	/**
 	* Applies a callback function to elements in an input array and assigns results to elements in an output array.
 	*
-	* @param x - input array
-	* @param y - output array
+	* @param x - input array object
+	* @param y - output array object
 	* @param stride - stride length for output array
 	* @param offset - starting index for output array
 	* @param fcn - callback function
 	* @param thisArg - callback execution context
-	* @returns output array
+	* @returns output array object
 	*
 	* @example
 	* var ones = require( '@stdlib/array/base/ones' );
@@ -166,8 +226,22 @@ interface Routine {
 	*
 	* var bool = ( out === y );
 	* // returns true
+	*
+	* @example
+	* var toAccessorArray = require( '@stdlib/array/to-accessor-array' );
+	* var ones = require( '@stdlib/array/base/ones' );
+	* var zeros = require( '@stdlib/array/base/zeros' );
+	*
+	* function scale( v ) {
+	*     return v * 10;
+	* }
+	* var x = ones( 4 );
+	* var y = zeros( x.length );
+	*
+	* var out = map.assign( toAccessorArray( x ), toAccessorArray( y ), 1, 0 scale );
+	* // y => [ 10, 10, 10, 10 ]
 	*/
-	assign<T = unknown, U = unknown, V = unknown>( x: Collection<T>, y: Collection<U>, stride: number, offset: number, fcn: Callback<T, U, V>, thisArg?: ThisParameterType<Callback<T, U, V>> ): Collection<U>;
+	assign<T = unknown, U extends InputArray<T> = InputArray<T>, V = unknown, W extends OutputArray<V> = OutputArray<V>, ThisArg = unknown>( x: U, y: W, stride: number, offset: number, fcn: Callback<T, U, V, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, V, ThisArg>> ): W;
 }
 
 /**