feat: Introduce BooleanT and boolean functions (#17)

This PR adds a boolean section, as well as an isNaN predicate on numbers. In a TypeDispatcher, when BooleanT is present, isNaN returns a BooleanT. However, in a numbers-only TypeDispatcher, it returns 1 or 0 instead. Moreover, when booleans are subsequently added to a numbers-only instance, isNaN properly reconfigures itself to return BooleanT.

No predicates that depend on approximate equality testing or a configuration object are implemented in this PR.

This PR also implements type matching and dispatching with implicit conversions, and adds an implicit conversion from BooleanT to NumberT.

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

src/number/Number.js

@@ -1,3 +0,0 @@
-import {Type} from '#core/Type.js'
-
-export const Number = new Type(n => typeof n === 'number')

src/number/NumberT.js

@@ -0,0 +1,7 @@
+import {Type} from '#core/Type.js'
+import {onType} from '#core/helpers.js'
+import {BooleanT} from '#boolean/BooleanT.js'
+
+export const NumberT = new Type(n => typeof n === 'number', {
+    from: onType(BooleanT, math => math.number.resolve([BooleanT])),
+})

src/number/__test__/Number.spec.js

@@ -1,11 +0,0 @@
-import assert from 'assert'
-import {Number} from '../Number.js'
-
-describe('Number Type', () => {
-   it('correctly recognizes numbers', () => {
-      assert(Number.test(3))
-      assert(Number.test(NaN))
-      assert(Number.test(Infinity))
-      assert(!Number.test("3"))
-   })
-})

src/number/__test__/NumberT.spec.js

@@ -0,0 +1,26 @@
+import assert from 'assert'
+import {NumberT} from '../NumberT.js'
+import {BooleanT} from '#boolean/BooleanT.js'
+import math from '#nanomath'
+
+describe('NumberT Type', () => {
+   it('correctly recognizes numbers', () => {
+      assert(NumberT.test(3))
+      assert(NumberT.test(NaN))
+      assert(NumberT.test(Infinity))
+      assert(!NumberT.test("3"))
+   })
+
+   it('can convert from BooleanT to NumberT', () => {
+      const convertImps = NumberT.from
+      let cnvBtoN
+      for (const [pattern, convFactory] of convertImps.patterns) {
+         if (pattern.match([BooleanT])) {
+            cnvBtoN = convFactory(math)
+            break
+         }
+      }
+      assert.strictEqual(cnvBtoN(true), 1)
+      assert.strictEqual(cnvBtoN(false), 0)
+   })
+})

src/number/__test__/type.spec.js

@@ -4,5 +4,9 @@ import math from '#nanomath'
 describe('number type operations', () => {
    it('converts to number', () => {
       assert.strictEqual(math.number(2.637), 2.637)
+      assert(isNaN(math.number(NaN)))
+      assert.strictEqual(math.number(true), 1)
+      assert.strictEqual(math.number(false), 0)
+      assert.strictEqual(math.number(), 0)
    })
 })

src/number/__test__/utils.spec.js

@@ -5,4 +5,9 @@ describe('number utilities', () => {
    it('clones a number', () => {
       assert.strictEqual(math.clone(2.637), 2.637)
    })
+   it('tests if a number is NaN', () => {
+      assert.strictEqual(math.isnan(NaN), true)
+      assert.strictEqual(math.isnan(Infinity), false)
+      assert.strictEqual(math.isnan(43), false)
+   })
 })

src/number/all.js

@@ -1,4 +1,4 @@
-export * as typeDefinition from './Number.js'
+export * as typeDefinition from './NumberT.js'
 export * as arithmetic from './arithmetic.js'
 export * as type from './type.js'
 export * as utils from './utils.js'

src/number/helpers.js

@@ -1,7 +1,9 @@
-import {Number} from './Number.js'
+import {NumberT} from './NumberT.js'
 
 import {onType} from '#core/helpers.js'
 import {Returns} from '#core/Type.js'
 
 export const plain = f => onType(
-   Array(f.length).fill(Number), Returns(Number, f))
+   Array(f.length).fill(NumberT), Returns(NumberT, f))
+
+export const boolnum = Returns(NumberT, p => p ? 1 : 0)

src/number/type.js

@@ -1,4 +1,12 @@
-import {plain} from './helpers.js'
+import {plain, boolnum} from './helpers.js'
+import {BooleanT} from '#boolean/BooleanT.js'
+import {Returns} from '#core/Type.js'
+import {NumberT} from '#number/NumberT.js'
+
+const num = f => Returns(NumberT, f)
 
-// Not much to do so far when there is only one type
 export const number = plain(a => a)
+number.also(
+   BooleanT, boolnum,
+   [], num(() => 0)
+)

src/number/utils.js

@@ -1,3 +1,12 @@
-import {plain} from './helpers.js'
+import {plain, boolnum} from './helpers.js'
+import {NumberT} from './NumberT.js'
+
+import {Returns} from '#core/Type.js'
+import {onType} from '#core/helpers.js'
 
 export const clone = plain(a => a)
+export const isnan = onType(NumberT, math => {
+    const {BooleanT} = math.types
+    if (BooleanT) return Returns(BooleanT, a => isNaN(a))
+    return Returns(NumberT, a => boolnum(isNaN(a)))
+})