Make opaque types easier to construct

Author: mkantor

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

@@ -1,9 +1,9 @@
+import { option as optionADT } from '../../../adts.js'
 import {
   makeFunctionType,
   makeObjectType,
-  makeOpaqueType,
+  makeOpaqueStringType,
   makeUnionType,
-  matchTypeFormat,
   type FunctionType,
   type Type,
   type UnionType,
@@ -16,77 +16,17 @@ export const nullType = makeUnionType('null', ['null'])
 
 export const boolean = makeUnionType('boolean', ['false', 'true'])
 
-export const string = makeOpaqueType('string', {
-  isAssignableFrom: source =>
-    matchTypeFormat(source, {
-      // functions cannot be assigned to `string`
-      function: _ => false,
-      // `string` can't have object types assigned to it
-      object: _source => false,
-      // 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
-      union: source => {
-        for (const sourceMember of source.members) {
-          if (
-            typeof sourceMember !== 'string' &&
-            !string.isAssignableFrom(sourceMember)
-          ) {
-            return false
-          }
-        }
-        return true
-      },
-    }),
-  isAssignableTo: target =>
-    matchTypeFormat(target, {
-      // `string` cannot be assigned to a function type
-      function: _ => false,
-      // `string` can't be assigned to object types
-      object: _target => false,
-      // `string` (currently) has no opaque supertypes (its only supertype is itself)
-      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),
-    }),
+export const string = makeOpaqueStringType('string', {
+  isAssignableFromLiteralType: (_literalType: string) => true,
+  nearestOpaqueAssignableFrom: () => optionADT.makeSome(naturalNumber),
+  nearestOpaqueAssignableTo: () => optionADT.none,
 })
 
-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),
-    }),
+export const naturalNumber = makeOpaqueStringType('natural_number', {
+  isAssignableFromLiteralType: literalType =>
+    /(?:0|[1-9](?:[0-9])*)+/.test(literalType),
+  nearestOpaqueAssignableFrom: () => optionADT.none,
+  nearestOpaqueAssignableTo: () => optionADT.makeSome(string),
 })
 
 export const object = makeObjectType('object', {})

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

@@ -1,3 +1,5 @@
+import { option } from '../../../adts.js'
+import type { None, Some } from '../../../adts/option.js'
 import type { Atom } from '../../parsing.js'
 
 export type FunctionType = {
@@ -44,17 +46,83 @@ export type OpaqueType = {
   readonly isAssignableTo: (target: Type) => boolean
 }
 
-export const makeOpaqueType = (
+// TODO: Opaque object/function types?
+export const makeOpaqueStringType = (
   name: string,
-  computations: {
-    readonly isAssignableFrom: (source: Type) => boolean
-    readonly isAssignableTo: (target: Type) => boolean
-  },
-): OpaqueType => ({
-  name,
-  kind: 'opaque',
-  ...computations,
-})
+  subtyping: {
+    readonly isAssignableFromLiteralType: (literalType: string) => boolean
+  } & (
+    | {
+        readonly nearestOpaqueAssignableFrom: () => None
+        readonly nearestOpaqueAssignableTo: () => Some<OpaqueType>
+      }
+    | {
+        readonly nearestOpaqueAssignableFrom: () => Some<OpaqueType>
+        readonly nearestOpaqueAssignableTo: () => None
+      }
+    | {
+        readonly nearestOpaqueAssignableFrom: () => Some<OpaqueType>
+        readonly nearestOpaqueAssignableTo: () => Some<OpaqueType>
+      }
+  ),
+): OpaqueType => {
+  const self: OpaqueType = {
+    name,
+    kind: 'opaque',
+    isAssignableFrom: source =>
+      matchTypeFormat(source, {
+        function: _ => false,
+        object: _ => false,
+        opaque: source =>
+          source === self ||
+          option.match(subtyping.nearestOpaqueAssignableFrom(), {
+            none: () => false,
+            some: nearestOpaqueAssignableFrom =>
+              nearestOpaqueAssignableFrom.isAssignableFrom(source),
+          }),
+        parameter: source =>
+          self.isAssignableFrom(source.constraint.assignableTo),
+        union: source => {
+          for (const sourceMember of source.members) {
+            if (typeof sourceMember === 'string') {
+              if (!subtyping.isAssignableFromLiteralType(sourceMember)) {
+                return false
+              }
+            } else if (!self.isAssignableFrom(sourceMember)) {
+              return false
+            }
+          }
+          return true
+        },
+      }),
+    isAssignableTo: target =>
+      matchTypeFormat(target, {
+        function: _ => false,
+        object: _ => false,
+        opaque: target =>
+          target === self ||
+          option.match(subtyping.nearestOpaqueAssignableTo(), {
+            none: () => false,
+            some: nearestOpaqueAssignableTo =>
+              nearestOpaqueAssignableTo.isAssignableTo(target),
+          }),
+        parameter: _ => false,
+        union: target => {
+          for (const targetMember of target.members) {
+            if (
+              // Opaque types are never assignable to literal types.
+              typeof targetMember !== 'string' &&
+              self.isAssignableTo(targetMember)
+            ) {
+              return true
+            }
+          }
+          return false
+        },
+      }),
+  }
+  return self
+}
 
 export type TypeParameter = {
   readonly name: string