function unary0d( fcn, arrays, strategy, ibuf, ldims, cdims, opts, hasOpts, clbk, thisArg ) {
	var arr;
	var x;
	var y;
	var f;

	x = arrays[ 0 ];
	y = arrays[ 1 ];

	f = wrap( x.ref, x, ibuf, ldims, [], cdims, clbk, thisArg );

	arr = without( arrays, 1 );
	arr[ 0 ] = strategy( x );

	if ( hasOpts ) {
		y.accessors[ 1 ]( y.data, y.offset, fcn( arr, opts, f ) );
	} else {
		y.accessors[ 1 ]( y.data, y.offset, fcn( arr, f ) );
	}
}
Performs a reduction over a list of specified dimensions in an input ndarray according to a callback function and assigns results to a provided output ndarray.

@private
@param {Function} fcn - wrapper for a one-dimensional strided array reduction function
@param {Array<Object>} arrays - ndarrays
@param {Function} strategy - input ndarray reshape strategy
@param {NonNegativeIntegerArray} ibuf - workspace for storing iteration indices
@param {NonNegativeIntegerArray} ldims - list of loop dimensions
@param {NonNegativeIntegerArray} cdims - list of "core" dimensions
@param {Options} opts - function options
@param {boolean} hasOpts - boolean indicating whether to pass an options argument to a reduction function
@param {Function} clbk - callback function
@param {thisArg} thisArg - callback execution context
@returns {void}

@example
var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
var accessors = require( '@stdlib/array/base/accessors' );
var Float64Array = require( '@stdlib/array/float64' );
var zeros = require( '@stdlib/array/base/zeros' );
var maxBy = require( '@stdlib/stats/base/ndarray/max-by' );

function clbk( value ) {
   return value * 2.0;
}

// Create data buffers:
var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ) );
var ybuf = toAccessorArray( new Float64Array( [ 0.0 ] ) );

// Define the array shapes:
var xsh = [ 2, 2 ];
var ysh = [];

// Define the array strides:
var sx = [ 2, 1 ];
var sy = [ 0 ];

// Define the index offsets:
var ox = 0;
var oy = 0;

// Create an input ndarray-like object:
var x = {
    'dtype': 'float64',
    'data': xbuf,
    'shape': xsh,
    'strides': sx,
    'offset': ox,
    'order': 'row-major',
    'accessors': accessors( xbuf ).accessors
};

// Create an output ndarray-like object:
var y = {
    'dtype': 'float64',
    'data': ybuf,
    'shape': ysh,
    'strides': sy,
    'offset': oy,
    'order': 'row-major',
    'accessors': accessors( ybuf ).accessors
};

// Define a reshape strategy:
function strategy( x ) {
    return {
        'dtype': x.dtype,
        'data': x.data,
        'shape': [ 4 ],
        'strides': [ 1 ],
        'offset': x.offset,
        'order': x.order
    };
}

// Create a workspace array for storing iteration indices:
var ibuf = zeros( xsh.length );

// Define the loop and core dimensions:
var ldims = [];
var cdims = [ 0, 1 ];

// Perform a reduction:
unary0d( maxBy, [ x, y ], strategy, ibuf, ldims, cdims, {}, false, clbk, {} );

var v = y.data.get( 0 );
// returns 8.0