feat: add support for non-string data types

---
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: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - 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: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/assert/is-allowed-data-type-cast/README.md

@@ -42,7 +42,7 @@ var isAllowedCast = require( '@stdlib/ndarray/base/assert/is-allowed-data-type-c
 
 #### isAllowedCast( from, to, casting )
 
-Returns a boolean indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be cast to another ndarray [data type][@stdlib/ndarray/dtypes] according to a specified [`casting`][@stdlib/ndarray/casting-modes] mode.
+Returns a boolean indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be cast to another ndarray [data type][@stdlib/ndarray/dtypes] according to a specified [casting][@stdlib/ndarray/casting-modes] mode.
 
 ```javascript
 var bool = isAllowedCast( 'float32', 'float64', 'safe' );
@@ -52,14 +52,14 @@ bool = isAllowedCast( 'float64', 'int32', 'safe' );
 // returns false
 ```
 
-The following [`casting`][@stdlib/ndarray/casting-modes] modes are supported:
+The following [casting][@stdlib/ndarray/casting-modes] modes are supported:
 
--   `none`: only allow casting between identical types.
--   `equiv`: allow casting between identical and byte swapped types.
--   `safe`: only allow "safe" casts.
--   `mostly-safe`: allow "safe" casts and, for floating-point data types, downcasts.
--   `same-kind`: allow "safe" casts and casts within the same kind (e.g., between signed integers or between floats).
--   `unsafe`: allow casting between all types (including between integers and floats).
+-   **none**: only allow casting between identical types.
+-   **equiv**: allow casting between identical and byte swapped types.
+-   **safe**: only allow "safe" casts.
+-   **mostly-safe**: allow "safe" casts and, for floating-point data types, downcasts.
+-   **same-kind**: allow "safe" casts and casts within the same kind (e.g., between signed integers or between floats).
+-   **unsafe**: allow casting between all types (including between integers and floats).
 
 </section>
 
@@ -82,34 +82,21 @@ The following [`casting`][@stdlib/ndarray/casting-modes] modes are supported:
 <!-- eslint no-undef: "error" -->
 
 ```javascript
+var nCartesianProduct = require( '@stdlib/array/base/n-cartesian-product' );
+var unzip = require( '@stdlib/utils/unzip' );
 var dtypes = require( '@stdlib/ndarray/dtypes' );
 var modes = require( '@stdlib/ndarray/casting-modes' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
 var isAllowedCast = require( '@stdlib/ndarray/base/assert/is-allowed-data-type-cast' );
 
-var DTYPES;
-var MODES;
-var bool;
-var dt1;
-var dt2;
-var i;
-var j;
-var k;
-
-// Get a list of supported ndarray data types and casting modes:
-DTYPES = dtypes();
-MODES = modes();
-
-// For each data type and mode, determine whether one can cast to another data type...
-for ( i = 0; i < DTYPES.length; i++ ) {
-    dt1 = DTYPES[ i ];
-    for ( j = 0; j < DTYPES.length; j++ ) {
-        dt2 = DTYPES[ j ];
-        for ( k = 0; k < MODES.length; k++ ) {
-            bool = isAllowedCast( dt1, dt2, MODES[ k ] );
-            console.log( '%s => %s. %s: %s.', dt1, dt2, MODES[ k ], bool );
-        }
-    }
-}
+// Generate a list of dtype pairs and casting modes:
+var pairs = nCartesianProduct( dtypes(), dtypes(), modes() );
+
+// Unzip the list into individual arrays:
+var lists = unzip( pairs );
+
+// For each data type pair and mode, determine whether one can cast to another data type:
+logEachMap( '%s => %s. %s: %s.', lists[ 0 ], lists[ 1 ], lists[ 2 ], isAllowedCast );
 ```
 
 </section>

lib/node_modules/@stdlib/ndarray/base/assert/is-allowed-data-type-cast/docs/repl.txt

@@ -9,19 +9,19 @@
     - 'equiv': allow casting between identical and byte swapped types.
     - 'safe': only allow "safe" casts.
     - 'mostly-safe': allow "safe" casts and, for floating-point data types,
-      downcasts.
+    downcasts.
     - 'same-kind': allow "safe" casts and casts within the same kind (e.g.,
-      between signed integers or between floats).
+    between signed integers or between floats).
     - 'unsafe': allow casting between all types (including between integers and
-      floats).
+    floats).
 
     Parameters
     ----------
-    from: string
-        ndarray data type.
+    from: string|DataType
+        Data type to cast from.
 
-    to: string
-        ndarray data type.
+    to: string|DataType
+        Data type to cast to.
 
     casting: string
         ndarray casting mode.

lib/node_modules/@stdlib/ndarray/base/assert/is-allowed-data-type-cast/docs/types/index.d.ts

@@ -18,6 +18,10 @@
 
 // TypeScript Version: 4.1
 
+/// <reference types="@stdlib/types"/>
+
+import { DataType } from '@stdlib/types/ndarray';
+
 /**
 * Returns a boolean indicating if a provided ndarray data type can be cast to another ndarray data type according to a specified casting mode.
 *
@@ -33,7 +37,7 @@
 * bool = isAllowedCast( 'float64', 'int32', 'safe' );
 * // returns false
 */
-declare function isAllowedCast( from: string, to: string, casting: string ): boolean;
+declare function isAllowedCast( from: DataType, to: DataType, casting: string ): boolean;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/ndarray/base/assert/is-allowed-data-type-cast/examples/index.js

@@ -18,31 +18,18 @@
 
 'use strict';
 
+var nCartesianProduct = require( '@stdlib/array/base/n-cartesian-product' );
+var unzip = require( '@stdlib/utils/unzip' );
 var dtypes = require( '@stdlib/ndarray/dtypes' );
 var modes = require( '@stdlib/ndarray/casting-modes' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
 var isAllowedCast = require( './../lib' );
 
-var DTYPES;
-var MODES;
-var bool;
-var dt1;
-var dt2;
-var i;
-var j;
-var k;
+// Generate a list of dtype pairs and casting modes:
+var pairs = nCartesianProduct( dtypes(), dtypes(), modes() );
 
-// Get a list of supported ndarray data types and casting modes:
-DTYPES = dtypes();
-MODES = modes();
+// Unzip the list into individual arrays:
+var lists = unzip( pairs );
 
-// For each data type and mode, determine whether one can cast to another data type...
-for ( i = 0; i < DTYPES.length; i++ ) {
-	dt1 = DTYPES[ i ];
-	for ( j = 0; j < DTYPES.length; j++ ) {
-		dt2 = DTYPES[ j ];
-		for ( k = 0; k < MODES.length; k++ ) {
-			bool = isAllowedCast( dt1, dt2, MODES[ k ] );
-			console.log( '%s => %s. %s: %s.', dt1, dt2, MODES[ k ], bool );
-		}
-	}
-}
+// For each data type pair and mode, determine whether one can cast to another data type:
+logEachMap( '%s => %s. %s: %s.', lists[ 0 ], lists[ 1 ], lists[ 2 ], isAllowedCast );

lib/node_modules/@stdlib/ndarray/base/assert/is-allowed-data-type-cast/lib/main.js

@@ -23,15 +23,16 @@
 var isSafeCast = require( '@stdlib/ndarray/base/assert/is-safe-data-type-cast' );
 var isMostlySafeCast = require( '@stdlib/ndarray/base/assert/is-mostly-safe-data-type-cast' );
 var isSameKindCast = require( '@stdlib/ndarray/base/assert/is-same-kind-data-type-cast' );
+var resolveStr = require( '@stdlib/ndarray/base/dtype-resolve-str' );
 
 
 // MAIN //
 
 /**
 * Returns a boolean indicating if a provided ndarray data type can be cast to another ndarray data type according to a specified casting mode.
 *
-* @param {string} from - ndarray data type
-* @param {string} to - ndarray data type
+* @param {*} from - ndarray data type
+* @param {*} to - ndarray data type
 * @param {string} casting - ndarray casting mode
 * @returns {boolean} boolean indicating if a data type can be cast to another data type
 *
@@ -43,12 +44,18 @@ var isSameKindCast = require( '@stdlib/ndarray/base/assert/is-same-kind-data-typ
 * // returns false
 */
 function isAllowedCast( from, to, casting ) {
+	var dt1;
+	var dt2;
+
 	// Anything goes for "unsafe" casting...
 	if ( casting === 'unsafe' ) {
 		return true;
 	}
+	dt1 = resolveStr( from );
+	dt2 = resolveStr( to );
+
 	// "Casting" to the same data type is always allowed, regardless of the casting mode...
-	if ( from === to ) {
+	if ( dt1 === dt2 ) {
 		return true;
 	}
 	// No casts between different data types are allowed in "none" or "equiv" casting modes...