feat: Add generic types and Complex numbers (#21)

Generic types can be called with argument(s) to produce a new type object, and if all types supplied as arguments are concrete, then the result will be a concrete type. The test of a generic type must determine if the entity is an instance of any specialization of the type; and it must also have a `refine` method that takes such an instance and returns its fully-specialized concrete type. It must also have a method `specializesTo` that takes a concrete type and returns whether that concrete type is a specialization of this generic type.

This commit also defines a generic Complex number type, that can have any type as its Component type (including another Complex number, to create e.g. quaternions), and defines the conversion/constructor function `complex`.

Reviewed-on: #21
Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Co-committed-by: Glen Whitney <glen@studioinfinity.org>

src/complex/type.js

@@ -0,0 +1,28 @@
+import {Complex} from './Complex.js'
+import {onType} from "#core/helpers.js"
+import {Returns} from "#core/Type.js"
+import {Any} from "#core/TypePatterns.js"
+
+export const complex = onType(
+   Any, (math, T) => {
+      const z = math.zero(T)
+      if (math.hasnan(T)) {
+         const isnan = math.isnan.resolve([T])
+         const compnan = math.nan(Complex(T))
+         return Returns(Complex(T), r => {
+            if (isnan(r)) return compnan
+            return {re: r, im: z}
+         })
+      }
+      return Returns(Complex(T), r => ({re: r, im: z}))
+   },
+   [Any, Any], (math, [T, U]) => {
+      if (T !== U) {
+         throw new RangeError(
+            'mixed complex types disallowed '
+               + `(real ${T}, imaginary ${U})`)
+      }
+      return Returns(Complex(T), (r, m) => ({re: r, im: m}))
+   })
+
+