docs: rename parameter

---
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: 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/unary-accumulate/docs/repl.txt

@@ -1,5 +1,5 @@
 
-{{alias}}( arrays, initial, accumulator )
+{{alias}}( arrays, initial, clbk )
     Performs a reduction over elements in an input ndarray.
 
     A provided "ndarray" should be an object with the following properties:
@@ -12,19 +12,17 @@
     - order: specifies whether an ndarray is row-major (C-style) or column-major
     (Fortran-style).
 
-    The accumulator callback should be a binary function accepting two
-    arguments:
+    The callback function should be a binary function accepting two arguments:
 
     - accumulated: the accumulated result.
     - currentValue: the current ndarray element.
 
-    Each invocation of the accumulator callback should return an updated
-    accumulated result. This return value is subsequently provided to the
-    accumulator callback upon next invocation.
+    Each invocation of the callback should return an updated accumulated result.
+    This return value is subsequently provided to the callback upon next
+    invocation.
 
-    After invoking the accumulator callback for each element in a provided
-    ndarray, the function returns the return value from the last invocation of
-    the accumulator callback.
+    After invoking the callback for each element in a provided ndarray, the
+    function returns the return value from the last invocation of the callback.
 
     Parameters
     ----------
@@ -34,8 +32,8 @@
     initial: any
         Initial accumulator value.
 
-    accumulator: Function
-        Accumulator callback.
+    clbk: Function
+        Callback function.
 
     Returns
     -------

lib/node_modules/@stdlib/ndarray/base/unary-accumulate/docs/types/index.d.ts

@@ -24,20 +24,20 @@ import { ArrayLike } from '@stdlib/types/array';
 import { typedndarray } from '@stdlib/types/ndarray';
 
 /**
-* Accumulator callback invoked for each ndarray element.
+* Callback invoked for each ndarray element.
 *
 * @param acc - accumulated result
 * @param value - current ndarray element
 * @returns result
 */
-type Accumulator<T = unknown, U = unknown> = ( acc: T, value: U ) => T;
+type Callback<T = unknown, U = unknown> = ( acc: T, value: U ) => T;
 
 /**
 * Performs a reduction over elements in an ndarray.
 *
 * @param arrays - array-like object containing one input ndarray
 * @param initial - initial value
-* @param accumulator - callback function
+* @param clbk - callback function
 * @returns accumulated result
 *
 * @example
@@ -73,7 +73,7 @@ type Accumulator<T = unknown, U = unknown> = ( acc: T, value: U ) => T;
 * var v = accumulateUnary( [ x ], 0.0, add );
 * // returns 39.0
 */
-declare function accumulateUnary<T = unknown, U = unknown>( arrays: ArrayLike<typedndarray<U>>, initial: T, accumulator: Accumulator<T, U> ): T;
+declare function accumulateUnary<T = unknown, U = unknown>( arrays: ArrayLike<typedndarray<U>>, initial: T, clbk: Callback<T, U> ): T;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/ndarray/base/unary-accumulate/docs/types/test.ts

@@ -20,13 +20,13 @@ import zeros = require( '@stdlib/ndarray/zeros' );
 import accumulateUnary = require( './index' );
 
 /**
-* Accumulator callback.
+* Callback function.
 *
 * @param acc - accumulated result
 * @param x - input value
 * @returns accumulated result
 */
-function accumulator( acc: number, x: number ): number {
+function clbk( acc: number, x: number ): number {
 	return acc + x;
 }
 
@@ -38,22 +38,22 @@ function accumulator( acc: number, x: number ): number {
 	const x = zeros( [ 2, 2 ] );
 	const arrays = [ x ];
 
-	accumulateUnary( arrays, 0.0, accumulator ); // $ExpectType number
+	accumulateUnary( arrays, 0.0, clbk ); // $ExpectType number
 }
 
 // The compiler throws an error if the function is provided a first argument which is not an array-like object containing ndarray-like objects...
 {
-	accumulateUnary( 5, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( true, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( false, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( null, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( undefined, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( {}, 0.0, accumulator ); // $ExpectError
-	accumulateUnary( [ 1 ], 0.0, accumulator ); // $ExpectError
-	accumulateUnary( ( x: number ): number => x, 0.0, accumulator ); // $ExpectError
+	accumulateUnary( 5, 0.0, clbk ); // $ExpectError
+	accumulateUnary( true, 0.0, clbk ); // $ExpectError
+	accumulateUnary( false, 0.0, clbk ); // $ExpectError
+	accumulateUnary( null, 0.0, clbk ); // $ExpectError
+	accumulateUnary( undefined, 0.0, clbk ); // $ExpectError
+	accumulateUnary( {}, 0.0, clbk ); // $ExpectError
+	accumulateUnary( [ 1 ], 0.0, clbk ); // $ExpectError
+	accumulateUnary( ( x: number ): number => x, 0.0, clbk ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided a third argument which is not an accumulator function...
+// The compiler throws an error if the function is provided a third argument which is not a valid callback function...
 {
 	const x = zeros( [ 2, 2 ] );
 	const arrays = [ x ];
@@ -75,5 +75,5 @@ function accumulator( acc: number, x: number ): number {
 
 	accumulateUnary(); // $ExpectError
 	accumulateUnary( arrays ); // $ExpectError
-	accumulateUnary( arrays, 0.0, accumulator, {} ); // $ExpectError
+	accumulateUnary( arrays, 0.0, clbk, {} ); // $ExpectError
 }