function setSlice( target, property, value, receiver, ctx ) {
	var vdt;
	var dt;
	var s;

	s = ctx.prop2slice( target, property, ctx.strict );
	if ( s === null ) {
		// If unable to parse the property as an indexing expression, signal that we were unable to perform slice assignment:
		return false;
	}
	if ( !isndarrayLike( value ) ) {
		dt = ctx.dtype;

		// If the target array data type is "generic", we can just go ahead and "cast" to the target array data type...
		if ( dt === 'generic' ) {
			value = scalar2ndarray( value, options( dt ) );
		}
		// If the input value is a real-valued number, we need to inspect the value to determine whether we can safely cast the value to the target array data type...
		else if ( isNumber( value ) ) {
			// If the target array has a floating-point data type, we can just go ahead and cast the input scalar to the target array data type, as number literals are, by default, double-precision floating-point values and casting to lower-precision floating-point is allowed...
			if ( isFloatingDataType( dt ) ) {
				value = scalar2ndarray( value, options( dt ) );
			}
			// If the target array has an unsigned integer data type, then the assigned value must be a compatible nonnegative integer value...
			else if ( isUnsignedIntegerDataType( dt ) ) {
				vdt = minDataType( value ); // note: we rely on data type resolution to handle the case where `value` is a non-integer value. In that case, `vdt` will resolve to a floating-point data type and `isSafeCast` will evaluate to `false`
				if ( isSafeCast( vdt, dt ) ) {
					value = scalar2ndarray( value, options( dt ) );
				} else {
					throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', vdt, dt ) );
				}
			}
			// If the target array has a signed integer data type, then the assigned value must be a compatible integer value...
			else if ( isSignedIntegerDataType( dt ) ) {
				if ( !isInteger( value ) ) {
					throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', minDataType( value ), dt ) );
				}
				// Manually resolve the minimum data type of the closest "kind" necessary for storing a scalar value, as `minDataType()` defaults to unsigned integer data types when a scalar value is greater than or equal to zero...
				if ( value < 0 ) {
					vdt = minDataType( value );
				} else if ( value <= INT8_MAX ) { // TODO: consider moving this logic to `@stdlib/ndarray/base/min-signed-intger-dtype` where the interface can assume that `value` is integer-valued
					vdt = 'int8';
				} else if ( value <= INT16_MAX ) {
					vdt = 'int16';
				} else if ( value <= INT32_MAX ) {
					vdt = 'int32';
				} else {
					vdt = 'float64';
				}
				if ( isSafeCast( vdt, dt ) ) {
					value = scalar2ndarray( value, options( dt ) );
				} else {
					throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', vdt, dt ) );
				}
			}
			// If the target array has "binary" data type, then the assigned value must be a compatible nonnegative integer value...
			else if ( dt === 'binary' ) {
				vdt = minDataType( value );
				if ( vdt === 'uint8' ) {
					value = scalar2ndarray( value, options( dt ) );
				} else {
					throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', vdt, dt ) );
				}
			}
			// If we reach this point, we must be dealing with an unexpected target array data type...
			else {
				// Raise an exception in order to flag that, in order to perform assignment, we need to add explicit support for additional data types:
				throw new TypeError( format( 'invalid operation. Unsupported target array data type. Data type: `%s`.', dt ) );
			}
		}
		// If the target array is not "generic" and the input value is a complex number, then the target array data type must also have a complex number data type...
		else if ( isComplexLike( value ) ) {
			if ( !isComplexDataType( dt ) ) {
				throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', complexDataType( value ), dt ) );
			}
			value = scalar2ndarray( value, options( dt ) );
		}
		// If the target array is not "generic" and the input value is neither a real- or complex-valued number, raise an exception in order to flag that, in order to perform assignment, we need to add explicit support for additional data types...
		else {
			throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', typeof value, dt ) );
		}
	}
	try {
		sliceAssign( value, receiver, s, ctx.strict );
	} catch ( err ) {
		throw new err.constructor( errMessage( err.message ) );
	}
	return true;
}
Sets element values belonging to the ndarray view specified by an indexing expression.

@private
@param {Object} target - target object
@param {string} property - indexing expression
@param {*} value - new value
@param {Object} receiver - the proxy object or an object inheriting from the proxy
@param {Object} ctx - context object
@param {string} ctx.dtype - ndarray data type
@param {Function} ctx.prop2slice - function for converting an indexing expression to a slice
@param {boolean} ctx.strict - boolean indicating whether to enforce strict bounds checking
@throws {Error} invalid slice operation
@throws {RangeError} number of slice dimensions must match the number of array dimensions
@throws {Error} assigned value must be broadcast compatible with target array view
@throws {TypeError} assigned value cannot be safely cast to the target array data type
@throws {TypeError} target array must have a supported data type
@returns {boolean} boolean indicating whether assignment succeeded