function dispatchBy( fcns, types, data, nargs, nin, nout ) {
	var strideArgs;
	var hasOffsets;
	var narrays;
	var nfcns;
	var iout;
	var fcn;

	if ( isFunction( fcns ) ) {
		fcn = fcns;
	} else if ( !isFunctionArray( fcns ) ) {
		throw new TypeError( format( 'invalid argument. First argument must be either a function or an array of functions. Value: `%s`.', fcns ) );
	}
	if ( !isCollection( types ) ) {
		throw new TypeError( format( 'invalid argument. Second argument must be an array-like object. Value: `%s`.', types ) );
	}
	if ( !isCollection( data ) && data !== null ) {
		throw new TypeError( format( 'invalid argument. Third argument must be an array-like object or null. Value: `%s`.', data ) );
	}
	if ( !isPositiveInteger( nargs ) ) {
		throw new TypeError( format( 'invalid argument. Fourth argument must be a positive integer. Value: `%s`.', nargs ) );
	}
	if ( !isNonNegativeInteger( nin ) ) {
		throw new TypeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%s`.', nin ) );
	}
	if ( !isNonNegativeInteger( nout ) ) {
		throw new TypeError( format( 'invalid argument. Sixth argument must be a nonnegative integer. Value: `%s`.', nout ) );
	}
	narrays = nin + nout;
	if ( narrays === 0 ) {
		throw new Error( 'invalid arguments. Interface must accept at least one strided input and/or output array. Based on the provided arguments, `nin+nout` equals `0`.' );
	}
	if ( fcn ) {
		nfcns = types.length / narrays;
		if ( !isInteger( nfcns ) ) {
			throw new Error( 'invalid argument. Unexpected number of types. A type must be specified for each strided input and output array for each provided strided array function.' );
		}
	} else {
		nfcns = fcns.length;
		if ( types.length !== nfcns*narrays ) {
			throw new Error( 'invalid argument. Unexpected number of types. A type must be specified for each strided input and output array for each provided strided array function.' );
		}
	}
	if ( data && data.length !== nfcns ) {
		throw new Error( 'invalid argument. The third argument must have the same number of elements as the first argument.' );
	}
	// Determine whether the strided array interface includes offsets:
	if ( (narrays*3)+2 === nargs ) {
		hasOffsets = false;
	} else if ( (narrays*4)+2 === nargs ) {
		hasOffsets = true;
	} else {
		throw new Error( 'invalid argument. Fourth argument is incompatible with the number of strided input and output arrays.' );
	}
	// Determine the "stride" for accessing related arguments:
	if ( hasOffsets ) {
		strideArgs = 4;
	} else {
		strideArgs = 3;
	}
	// Compute the index of the first output strided array argument:
	iout = ( nin*strideArgs ) + 1;

	return dispatcher;

	/**
	* Strided array function interface which performs multiple dispatch.
	*
	* @private
	* @param {integer} N - number of indexed elements
	* @param {*} dtypeX - data type for `x`
	* @param {Collection} x - strided array
	* @param {integer} strideX - index increment for `x`
	* @param {...(Collection|integer|NonNegativeInteger)} args - array arguments (data types, arrays, strides, and offsets)
	* @param {Callback} clbk - callback function
	* @param {*} [thisArg] - callback function execution context
	* @throws {Error} insufficient arguments
	* @throws {Error} too many arguments
	* @throws {TypeError} first argument must be an integer
	* @throws {TypeError} input array strides must be integers
	* @throws {TypeError} output array strides must be integers
	* @throws {TypeError} input array offsets must be nonnegative integers
	* @throws {TypeError} output array offsets must be nonnegative integers
	* @throws {TypeError} input array arguments must be array-like objects
	* @throws {TypeError} output array arguments must be array-like objects
	* @throws {RangeError} input array arguments must have sufficient elements based on the associated stride and the number of indexed elements
	* @throws {RangeError} output array arguments must have sufficient elements based on the associated stride and the number of indexed elements
	* @throws {TypeError} unable to resolve a strided array function supporting the provided array argument data types
	* @throws {TypeError} callback argument must be a function
	* @returns {(Collection|Array<Collection>|void)} destination array(s)
	*/
	function dispatcher() {
		var strides;
		var offsets;
		var thisArg;
		var arrays;
		var dtypes;
		var shape;
		var argc;
		var clbk;
		var idx;
		var N;
		var v;
		var f;
		var i;
		var j;

		argc = arguments.length;
		if ( argc !== nargs ) {
			if ( argc < nargs ) {
				throw new Error( 'invalid invocation. Insufficient arguments.' );
			}
			// Check for a callback execution context argument...
			if ( argc === nargs+1 ) {
				argc -= 1;
				thisArg = arguments[ argc ];
			} else {
				throw new Error( 'invalid invocation. Too many arguments.' );
			}
		}
		N = arguments[ 0 ];
		if ( !isInteger( N ) ) {
			throw new TypeError( format( 'invalid argument. First argument must be an integer. Value: `%s`.', N ) );
		}
		shape = [ N ];

		clbk = arguments[ argc-1 ];
		if ( !isFunction( clbk ) ) {
			throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', clbk ) );
		}
		// data types for both input and output strided arrays are every `strideArgs` arguments beginning from the second argument...
		dtypes = [];
		for ( i = 1; i < nargs; i += strideArgs ) {
			dtypes.push( arguments[ i ] );
		}

		// Strides for both input and output strided arrays are every `strideArgs` arguments beginning from the fourth argument...
		strides = [];
		for ( i = 3; i < nargs; i += strideArgs ) {
			v = arguments[ i ];
			if ( !isInteger( v ) ) {
				if ( i < iout ) {
					throw new TypeError( format( 'invalid argument. Input array stride must be an integer. Value: `%s`.', v ) );
				} else {
					throw new TypeError( format( 'invalid argument. Output array stride must be an integer. Value: `%s`.', v ) );
				}
			}
			strides.push( v );
		}
		if ( hasOffsets ) {
			// Offsets for both input and output strided arrays are every `strideArgs` arguments beginning from the fifth argument...
			offsets = [];
			for ( i = 4; i < nargs; i += strideArgs ) {
				v = arguments[ i ];
				if ( !isNonNegativeInteger( v ) ) {
					if ( i < iout ) {
						throw new TypeError( format( 'invalid argument. Input array offset must be a nonnegative integer. Value: `%s`.', v ) );
					} else {
						throw new TypeError( format( 'invalid argument. Output array offset must be a nonnegative integer. Value: `%s`.', v ) );
					}
				}
				offsets.push( v );
			}
		}
		// Input and output strided arrays are every `strideArgs` arguments beginning from the third argument...
		arrays = [];
		for ( i = 2; i < nargs; i += strideArgs ) {
			v = arguments[ i ];
			if ( !isCollection( v ) ) {
				if ( i < iout ) {
					throw new TypeError( format( 'invalid argument. Input array must be an array-like object. Value: `%s`.', v ) );
				} else {
					throw new TypeError( format( 'invalid argument. Output array must be an array-like object. Value: `%s`.', v ) );
				}
			}
			j = (i-2) / strideArgs;
			if ( hasOffsets ) {
				idx = offsets[ j ] + ( (N-1)*strides[j] );
				if ( N > 0 && (idx < 0 || idx >= v.length) ) {
					if ( i < iout ) {
						throw new RangeError( 'invalid argument. Input array has insufficient elements based on the associated stride and the number of indexed elements.' );
					} else {
						throw new RangeError( 'invalid argument. Output array has insufficient elements based on the associated stride and the number of indexed elements.' );
					}
				}
			} else if ( (N-1)*abs(strides[j]) >= v.length ) {
				if ( i < iout ) {
					throw new RangeError( 'invalid argument. Input array has insufficient elements based on the associated stride and the number of indexed elements.' );
				} else {
					throw new RangeError( 'invalid argument. Output array has insufficient elements based on the associated stride and the number of indexed elements.' );
				}
			}
			arrays.push( v );
		}
		// Resolve the strided array function satisfying the input array types:
		idx = indexOfTypes( nfcns, narrays, types, narrays, 1, 0, dtypes, 1, 0 ); // eslint-disable-line max-len

		// Check whether we were able to successfully resolve a strided array function:
		if ( idx < 0 ) {
			throw new TypeError( 'invalid arguments. Unable to resolve a strided array function supporting the provided array argument data types.' );
		}
		// Retrieve the strided array function:
		if ( fcn ) {
			f = fcn;
		} else {
			f = fcns[ idx ];
		}
		// Evaluate the strided array function:
		if ( data ) {
			if ( hasOffsets ) {
				f( arrays, shape, strides, offsets, data[ idx ], clbk, thisArg ); // eslint-disable-line max-len
			} else {
				f( arrays, shape, strides, data[ idx ], clbk, thisArg );
			}
		} else if ( hasOffsets ) {
			f( arrays, shape, strides, offsets, clbk, thisArg );
		} else {
			f( arrays, shape, strides, clbk, thisArg );
		}
		if ( nout === 1 ) {
			return arrays[ narrays-1 ];
		}
		if ( nout === 0 ) {
			return;
		}
		return arrays.slice( nin );
	}
}
Returns a strided array function interface which accepts a callback function and performs multiple dispatch.

@param {(FunctionArray|Function)} fcns - list of strided array functions
@param {Collection} types - one-dimensional list of strided array argument data types
@param {(Collection|null)} data - strided array function data (e.g., callbacks)
@param {PositiveInteger} nargs - total number of strided array function interface arguments (including data types, strides, offsets, and the callback function)
@param {NonNegativeInteger} nin - number of input strided arrays
@param {NonNegativeInteger} nout - number of output strided arrays
@throws {TypeError} first argument must be either a function or an array of functions
@throws {TypeError} second argument must be an an array-like object
@throws {TypeError} third argument must be an array-like object or `null`
@throws {Error} third and first arguments must have the same number of elements
@throws {TypeError} fourth argument must be a positive integer
@throws {TypeError} fifth argument must be a nonnegative integer
@throws {TypeError} sixth argument must be a nonnegative integer
@throws {Error} fourth argument must be compatible with the specified number of input and output arrays
@throws {Error} number of types must match the number of functions times the total number of array arguments for each function
@throws {Error} interface must accept at least one strided input and/or output array
@returns {Function} strided array function interface

@example
var unaryBy = require( '@stdlib/strided/base/unary-by' );
var abs = require( '@stdlib/math/base/special/abs' );
var identity = require( '@stdlib/number/float64/base/identity' );
var Float64Array = require( '@stdlib/array/float64' );

var types = [
    'float64', 'float64'
];

var data = [
    abs
];

var strided = dispatchBy( unaryBy, types, data, 8, 1, 1 );

// ...

var x = new Float64Array( [ -1.0, -2.0, -3.0, -4.0, -5.0 ] );
var y = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );

strided( x.length, 'float64', x, 1, 'float64', y, 1, identity );
// y => <Float64Array>[ 1.0, 2.0, 3.0, 4.0, 5.0 ]