Add a natural_number type

Author: mkantor

src/language/semantics/type-system.test.ts

@@ -2,6 +2,7 @@ import { testCases } from '../../test-utilities.test.js'
 import {
   boolean,
   functionType,
+  naturalNumber,
   nothing,
   nullType,
   object,
@@ -88,11 +89,13 @@ typeAssignabilitySuite('prelude types (assignable)', [
   [[nothing, nothing], true],
   [[nullType, nullType], true],
   [[boolean, boolean], true],
+  [[naturalNumber, naturalNumber], true],
   [[string, string], true],
   [[object, object], true],
   [[functionType, functionType], true],
   [[something, something], true],
   [[nothing, nullType], true],
+  [[nothing, naturalNumber], true],
   [[nothing, string], true],
   [[nothing, object], true],
   [[nothing, functionType], true],
@@ -101,6 +104,8 @@ typeAssignabilitySuite('prelude types (assignable)', [
   [[nullType, something], true],
   [[boolean, string], true],
   [[boolean, something], true],
+  [[naturalNumber, string], true],
+  [[naturalNumber, something], true],
   [[string, something], true],
   [[object, something], true],
   [[functionType, something], true],
@@ -109,30 +114,36 @@ typeAssignabilitySuite('prelude types (assignable)', [
 typeAssignabilitySuite('prelude types (not assignable)', [
   [[nullType, nothing], false],
   [[nullType, boolean], false],
+  [[nullType, naturalNumber], false],
   [[nullType, object], false],
   [[nullType, functionType], false],
   [[boolean, nothing], false],
   [[boolean, nullType], false],
+  [[boolean, naturalNumber], false],
   [[boolean, object], false],
   [[boolean, functionType], false],
   [[string, nothing], false],
   [[string, nullType], false],
   [[string, boolean], false],
+  [[string, naturalNumber], false],
   [[string, object], false],
   [[string, functionType], false],
   [[object, nothing], false],
   [[object, nullType], false],
   [[object, boolean], false],
+  [[object, naturalNumber], false],
   [[object, string], false],
   [[object, functionType], false],
   [[functionType, nothing], false],
   [[functionType, nullType], false],
   [[functionType, boolean], false],
+  [[functionType, naturalNumber], false],
   [[functionType, string], false],
   [[functionType, object], false],
   [[something, nothing], false],
   [[something, nullType], false],
   [[something, boolean], false],
+  [[something, naturalNumber], false],
   [[something, string], false],
   [[something, object], false],
   [[something, functionType], false],
@@ -143,6 +154,16 @@ typeAssignabilitySuite('custom types (assignable)', [
   [[makeUnionType('', ['a']), string], true],
   [[makeUnionType('', ['a', 'b']), string], true],
   [[makeUnionType('', ['a']), makeUnionType('', [string, 'b'])], true],
+
+  [[makeUnionType('', ['1']), naturalNumber], true],
+  [[makeUnionType('', ['0', '1']), naturalNumber], true],
+  [
+    [
+      makeUnionType('', ['9876543210']),
+      makeUnionType('', [naturalNumber, 'not a number']),
+    ],
+    true,
+  ],
   [
     [
       makeObjectType('', {

src/language/semantics/type-system/prelude-types.ts

@@ -23,8 +23,8 @@ export const string = makeOpaqueType('string', {
       function: _ => false,
       // `string` can't have object types assigned to it
       object: _source => false,
-      // `string` (currently) has no opaque subtypes (its only subtype is itself)
-      opaque: source => source === string,
+      // the only opaque subtypes of `string` are `naturalNumber` and itself
+      opaque: source => source === string || source === naturalNumber,
       parameter: source =>
         string.isAssignableFrom(source.constraint.assignableTo),
       // `string` can have a union assigned to it if all of its members can be assigned to it
@@ -50,7 +50,42 @@ export const string = makeOpaqueType('string', {
       opaque: target => target === string,
       parameter: target => target.constraint.assignableTo === string,
       // `string` can only be assigned to a union type if `string` is one of its members
-      union: target => target.members.has(string), // FIXME this and other checks will only work if i make sure all references to `string` use exactly this instance! otherwise i need to use TypeIDs
+      union: target => target.members.has(string),
+    }),
+})
+
+export const naturalNumber = makeOpaqueType('natural_number', {
+  isAssignableFrom: source =>
+    matchTypeFormat(source, {
+      function: _ => false,
+      object: _source => false,
+      // `naturalNumber` (currently) has no opaque subtypes (its only subtype is itself)
+      opaque: source => source === naturalNumber,
+      parameter: source =>
+        naturalNumber.isAssignableFrom(source.constraint.assignableTo),
+      // `naturalNumber` can have a union assigned to it if all of its members can be assigned to it
+      union: source => {
+        for (const sourceMember of source.members) {
+          if (typeof sourceMember === 'string') {
+            if (!/(?:0|[1-9](?:[0-9])*)+/.test(sourceMember)) {
+              return false
+            }
+          } else if (!naturalNumber.isAssignableFrom(sourceMember)) {
+            return false
+          }
+        }
+        return true
+      },
+    }),
+  isAssignableTo: target =>
+    matchTypeFormat(target, {
+      function: _ => false,
+      object: _target => false,
+      opaque: target => target === naturalNumber || target === string,
+      parameter: target => target.constraint.assignableTo === naturalNumber,
+      // `naturalNumber` can only be assigned to a union type if `naturalNumber` is one of its members
+      union: target =>
+        target.members.has(naturalNumber) || target.members.has(string),
     }),
 })