function malloc() {
		var nargs;
		var dtype;
		var ctor;
		var arr;
		var out;
		var set;
		var get;
		var len;
		var i;

		nargs = arguments.length;
		if ( nargs && isString( arguments[ nargs-1 ] ) ) {
			nargs -= 1;
			dtype = arguments[ nargs ];
		} else {
			dtype = DEFAULT_DTYPE;
		}
		ctor = ctors( dtype );
		if ( ctor === null ) {
			throw new TypeError( format( 'invalid argument. Must provide a recognized data type. Value: `%s`.', dtype ) );
		}
		if ( nargs <= 0 ) {
			return new ctor( 0 );
		}
		// Check if provided a typed array length...
		if ( isNonNegativeInteger( arguments[ 0 ] ) ) {
			return typedarray( ctor, arguments[ 0 ], dtype );
		}
		// Check if provided an array-like object containing data elements...
		if ( isCollection( arguments[ 0 ] ) ) {
			arr = arguments[ 0 ];
			len = arr.length;
			if ( isComplex128Array( arr ) ) {
				arr = reinterpret128( arr, 0 );
			} else if ( isComplex64Array( arr ) ) {
				arr = reinterpret64( arr, 0 );
			} else if ( isBooleanArray( arr ) ) {
				arr = reinterpretBoolean( arr, 0 );
			} else if ( isComplexDataType( dtype ) ) {
				// Assume we've been provided an array of interleaved real and imaginary components...
				len /= 2;
			}
			out = typedarray( ctor, len, dtype );
			if ( out === null ) {
				return out;
			}
			if ( isCmplx128Array( out ) || isCmplx64Array( out ) || isBoolArray( out ) ) {
				out.set( arr );
				return out;
			}
			// Resolve element accessors in order to account for the possibility that `arr` is a complex number array. As we don't prohibit other "unsafe" casts (e.g., providing a `Float64Array` and specifying a `dtype` of `uint8`), we don't prohibit providing a complex number array and specifying a real `dtype`. The results will probably be unexpected/gibberish, but I am not sure we should be overly pedantic in ensuring users don't do ill-advised things...
			get = resolveGetter( arr );
			set = resolveSetter( out );
			for ( i = 0; i < len; i++ ) {
				set( out, i, get( arr, i ) );
			}
			return out;
		}
		throw new TypeError( format( 'invalid argument. First argument must be either an array length or an array-like object. Value: `%s`.', arguments[ 0 ] ) );
	}
Returns an uninitialized typed array.

## Notes

-   Memory is **not** initialized.
-   Memory is lazily allocated.
-   If the function returns `null`, the function was unable to allocate a new typed array from the typed array pool (most likely due to insufficient memory).

@private
@param {(NonNegativeInteger|Collection)} [arg] - an array length or an array-like object
@param {string} [dtype="float64"] - data type
@throws {TypeError} must provide a valid array length or an array-like object
@throws {TypeError} must provide a recognized data type
@returns {(TypedArray|null)} typed array or null