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: na
  - 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-same-kind-data-type-cast/README.md

@@ -42,7 +42,7 @@ var isSameKindCast = require( '@stdlib/ndarray/base/assert/is-same-kind-data-typ
 
 #### isSameKindCast( from, to )
 
-Returns a `boolean` indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be safely cast to, or is of the same "kind" as, another ndarray [data type][@stdlib/ndarray/dtypes] (e.g., casting between signed integers or between floats).
+Returns a boolean indicating whether an ndarray [data type][@stdlib/ndarray/dtypes] can be safely cast to, or is of the same "kind" as, another ndarray [data type][@stdlib/ndarray/dtypes] (e.g., casting between signed integers or between floats).
 
 ```javascript
 var bool = isSameKindCast( 'float32', 'float64' );

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

@@ -5,11 +5,11 @@
 
     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.
 
     Returns
     -------

lib/node_modules/@stdlib/ndarray/base/assert/is-same-kind-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 safely cast to, or is of the same "kind" as, another ndarray data type.
 *
@@ -32,7 +36,7 @@
 * bool = isSameKindCast( 'uint16', 'int16' );
 * // returns false
 */
-declare function isSameKindCast( from: string, to: string ): boolean;
+declare function isSameKindCast( from: DataType, to: DataType ): boolean;
 
 
 // EXPORTS //

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

@@ -21,6 +21,7 @@
 // MODULES //
 
 var sameKindCasts = require( '@stdlib/ndarray/same-kind-casts' );
+var resolveStr = require( '@stdlib/ndarray/base/dtype-resolve-str' );
 
 
 // VARIABLES //
@@ -33,8 +34,8 @@ var TABLE = sameKindCasts();
 /**
 * Returns a boolean indicating if a provided ndarray data type can be safely cast to, or is of the same "kind" as, another ndarray data type.
 *
-* @param {string} from - ndarray data type
-* @param {string} to - ndarray data type
+* @param {*} from - ndarray data type
+* @param {*} to - ndarray data type
 * @returns {boolean} boolean indicating if a data type can be cast to another data type
 *
 * @example
@@ -45,10 +46,17 @@ var TABLE = sameKindCasts();
 * // returns false
 */
 function isSameKindCast( from, to ) {
-	if ( from === to ) {
+	var t;
+	from = resolveStr( from );
+	to = resolveStr( to );
+	if ( from === to ) { // note: for "struct" data types, require strict equality to be considered a safe cast
 		return true;
 	}
-	return ( TABLE[ from ][ to ] > 0 );
+	t = TABLE[ from ];
+	if ( t ) {
+		return t[ to ] > 0;
+	}
+	return false;
 }
 
 

lib/node_modules/@stdlib/ndarray/base/assert/is-same-kind-data-type-cast/test/test.js

@@ -16,13 +16,18 @@
 * limitations under the License.
 */
 
+/* eslint-disable max-len */
+
 'use strict';
 
 // MODULES //
 
 var tape = require( 'tape' );
+var DataType = require( '@stdlib/ndarray/dtype-ctor' );
+var structFactory = require( '@stdlib/dstructs/struct' );
 var dtypes = require( '@stdlib/ndarray/dtypes' );
 var sameKindCasts = require( '@stdlib/ndarray/same-kind-casts' );
+var str2enum = require( '@stdlib/ndarray/base/dtype-str2enum' );
 var isSameKindCast = require( './../lib' );
 
 
@@ -40,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type', function test( t ) {
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (strings)', function test( t ) {
 	var expected;
 	var actual;
 	var dt;
@@ -57,3 +62,113 @@ tape( 'the function returns a boolean indicating if an ndarray data type can be
 	}
 	t.end();
 });
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (enums)', function test( t ) {
+	var expected;
+	var actual;
+	var dt;
+	var i;
+	var j;
+
+	for ( i = 0; i < DTYPES.length; i++ ) {
+		dt = DTYPES[ i ];
+		for ( j = 0; j < DTYPES.length; j++ ) {
+			expected = ( SAME_KIND_CASTS[ dt ][ DTYPES[j] ] > 0 );
+			actual = isSameKindCast( str2enum( dt ), str2enum( DTYPES[ j ] ) );
+			t.strictEqual( actual, expected, 'returns expected value. from: '+dt+'. to: '+DTYPES[j]+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (data type, strings)', function test( t ) {
+	var expected;
+	var actual;
+	var dt;
+	var i;
+	var j;
+
+	for ( i = 0; i < DTYPES.length; i++ ) {
+		dt = DTYPES[ i ];
+		for ( j = 0; j < DTYPES.length; j++ ) {
+			expected = ( SAME_KIND_CASTS[ dt ][ DTYPES[j] ] > 0 );
+			actual = isSameKindCast( new DataType( dt ), new DataType( DTYPES[ j ] ) );
+			t.strictEqual( actual, expected, 'returns expected value. from: '+dt+'. to: '+DTYPES[j]+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (struct)', function test( t ) {
+	var schemas;
+	var values;
+	var actual;
+	var dt;
+	var i;
+
+	schemas = [
+		[
+			{
+				'name': 'foo',
+				'type': 'float64'
+			}
+		],
+		[
+			{
+				'name': 'bar',
+				'type': 'float32'
+			}
+		]
+	];
+	values = [
+		structFactory( schemas[ 0 ] ),
+		structFactory( schemas[ 1 ] )
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		dt = values[ i ];
+		actual = isSameKindCast( dt, dt );
+		t.strictEqual( actual, true, 'returns expected value. from: '+dt.layout+'. to: '+dt.layout+'.' );
+	}
+	actual = isSameKindCast( values[ 0 ], values[ 1 ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a boolean indicating if an ndarray data type can be cast to another ndarray data type (data type, struct)', function test( t ) {
+	var schemas;
+	var values;
+	var actual;
+	var dt;
+	var i;
+
+	schemas = [
+		[
+			{
+				'name': 'foo',
+				'type': 'float64'
+			}
+		],
+		[
+			{
+				'name': 'bar',
+				'type': 'float32'
+			}
+		]
+	];
+	values = [
+		structFactory( schemas[ 0 ] ),
+		structFactory( schemas[ 1 ] )
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		dt = values[ i ];
+		actual = isSameKindCast( new DataType( dt ), new DataType( dt ) );
+		t.strictEqual( actual, true, 'returns expected value. from: '+dt.layout+'. to: '+dt.layout+'.' );
+	}
+	actual = isSameKindCast( new DataType( values[ 0 ] ), new DataType( values[ 1 ] ) );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	t.end();
+});