Statically fix the set of keywords

Author: mkantor

src/language/compiling.ts

@@ -1,2 +1,2 @@
 export { compile } from './compiling/compiler.js'
-export { handlers as keywordHandlers } from './compiling/semantics/keywords.js'
+export { keywordHandlers } from './compiling/semantics/keywords.js'

src/language/compiling/compiler.ts

@@ -3,12 +3,12 @@ import type { CompilationError } from '../errors.js'
 import type { JSONValueForbiddingSymbolicKeys } from '../parsing.js'
 import { canonicalize } from '../parsing.js'
 import { elaborate, serialize, type Output } from '../semantics.js'
-import * as keywordModule from './semantics/keywords.js'
+import { keywordHandlers } from './semantics/keywords.js'
 
 export const compile = (
   input: JSONValueForbiddingSymbolicKeys,
 ): Either<CompilationError, Output> => {
   const syntaxTree = canonicalize(input)
-  const semanticGraphResult = elaborate(syntaxTree, keywordModule)
+  const semanticGraphResult = elaborate(syntaxTree, keywordHandlers)
   return either.flatMap(semanticGraphResult, serialize)
 }

src/language/compiling/semantics.test.ts

@@ -13,12 +13,12 @@ import {
   type ObjectNode,
 } from '../semantics.js'
 import type { SemanticGraph } from '../semantics/semantic-graph.js'
-import * as keywordModule from './semantics/keywords.js'
+import { keywordHandlers } from './semantics/keywords.js'
 import { prelude } from './semantics/prelude.js'
 
 const elaborationSuite = testCases(
   (input: Atom | Molecule) =>
-    elaborate(withPhantomData<never>()(input), keywordModule),
+    elaborate(withPhantomData<never>()(input), keywordHandlers),
   input => `elaborating expressions in \`${JSON.stringify(input)}\``,
 )
 

src/language/compiling/semantics/expressions/function-expression.ts

@@ -21,7 +21,7 @@ import {
   type SemanticGraph,
   type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
-import { handlers, isKeyword } from '../keywords.js'
+import { keywordHandlers } from '../keywords.js'
 import {
   asSemanticGraph,
   readArgumentsFromExpression,
@@ -115,7 +115,9 @@ const apply = (
       updatedProgram =>
         elaborateWithContext(
           serializedBody,
-          { handlers, isKeyword },
+          // TODO: This should use compile-time or runtime handlers when appropriate. Perhaps
+          // keyword handlers should be part of `ExpressionContext`?
+          keywordHandlers,
           {
             location: [...context.location, returnKey],
             program: updatedProgram,

src/language/compiling/semantics/keywords.ts

@@ -1,4 +1,4 @@
-import { type KeywordModule } from '../../semantics.js'
+import { type KeywordHandlers } from '../../semantics.js'
 import {
   applyKeyword,
   applyKeywordHandler,
@@ -24,7 +24,7 @@ import {
   todoKeywordHandler,
 } from './expressions/todo-expression.js'
 
-export const handlers = {
+export const keywordHandlers: KeywordHandlers = {
   /**
    * Calls the given function with a given argument.
    */
@@ -54,11 +54,4 @@ export const handlers = {
    * Ignores all properties and evaluates to an empty object.
    */
   [todoKeyword]: todoKeywordHandler,
-} satisfies KeywordModule<`@${string}`>['handlers']
-
-export type Keyword = keyof typeof handlers
-
-// `isKeyword` is correct as long as `handlers` does not have excess properties.
-const allKeywords = new Set(Object.keys(handlers))
-export const isKeyword = (input: string): input is Keyword =>
-  allKeywords.has(input)
+}

src/language/runtime/evaluator.ts

@@ -3,12 +3,12 @@ import type { RuntimeError } from '../errors.js'
 import type { JSONValueForbiddingSymbolicKeys } from '../parsing.js'
 import { canonicalize } from '../parsing.js'
 import { elaborate, serialize, type Output } from '../semantics.js'
-import * as keywordModule from './keywords.js'
+import { keywordHandlers } from './keywords.js'
 
 export const evaluate = (
   input: JSONValueForbiddingSymbolicKeys,
 ): Either<RuntimeError, Output> => {
   const syntaxTree = canonicalize(input)
-  const semanticGraphResult = elaborate(syntaxTree, keywordModule)
+  const semanticGraphResult = elaborate(syntaxTree, keywordHandlers)
   return either.flatMap(semanticGraphResult, serialize)
 }

src/language/runtime/keywords.ts

@@ -10,8 +10,7 @@ import {
   serialize,
   types,
   type Expression,
-  type KeywordElaborationResult,
-  type KeywordModule,
+  type KeywordHandlers,
   type SemanticGraph,
 } from '../semantics.js'
 import { lookupPropertyOfObjectNode } from '../semantics/object-node.js'
@@ -125,12 +124,12 @@ const runtimeContext = makeObjectNode({
   }),
 })
 
-export const handlers = {
+export const keywordHandlers: KeywordHandlers = {
   ...compilerKeywordHandlers,
   /**
    * Evaluates the given function, passing runtime context captured in `world`.
    */
-  '@runtime': (expression): KeywordElaborationResult => {
+  '@runtime': expression => {
     const runtimeFunction = lookupWithinExpression(
       ['function', '1'],
       expression,
@@ -158,14 +157,7 @@ export const handlers = {
       }
     }
   },
-} satisfies KeywordModule<`@${string}`>['handlers']
-
-export type Keyword = keyof typeof handlers
-
-// `isKeyword` is correct as long as `handlers` does not have excess properties.
-const allKeywords = new Set(Object.keys(handlers))
-export const isKeyword = (input: string): input is Keyword =>
-  allKeywords.has(input)
+}
 
 const lookupWithinExpression = (
   keyAliases: [Atom, ...(readonly Atom[])],

src/language/semantics.ts

@@ -3,7 +3,7 @@ export {
   type ElaboratedSemanticGraph,
   type ExpressionContext,
   type KeywordElaborationResult,
-  type KeywordModule,
+  type KeywordHandlers,
 } from './semantics/expression-elaboration.js'
 export { isExpression, type Expression } from './semantics/expression.js'
 export {
@@ -12,6 +12,7 @@ export {
   type FunctionNode,
 } from './semantics/function-node.js'
 export { type KeyPath } from './semantics/key-path.js'
+export { isKeyword, type Keyword } from './semantics/keyword.js'
 export {
   isObjectNode,
   makeObjectNode,

src/language/semantics/expression-elaboration.ts

@@ -3,13 +3,14 @@ import { withPhantomData, type WithPhantomData } from '../../phantom-data.js'
 import type { Writable } from '../../utility-types.js'
 import type { ElaborationError, InvalidSyntaxTreeError } from '../errors.js'
 import type { Atom, Molecule, SyntaxTree } from '../parsing.js'
+import type { Expression } from './expression.js'
+import type { KeyPath } from './key-path.js'
+import { isKeyword, type Keyword } from './keyword.js'
 import {
   makeObjectNode,
   makeUnelaboratedObjectNode,
-  type KeyPath,
   type ObjectNode,
-} from '../semantics.js'
-import type { Expression } from './expression.js'
+} from './object-node.js'
 import {
   extractStringValueIfPossible,
   updateValueAtKeyPathInSemanticGraph,
@@ -32,16 +33,13 @@ export type KeywordHandler = (
   context: ExpressionContext,
 ) => KeywordElaborationResult
 
-export type KeywordModule<Keyword extends `@${string}`> = {
-  readonly isKeyword: (input: string) => input is Keyword
-  readonly handlers: Readonly<Record<Keyword, KeywordHandler>>
-}
+export type KeywordHandlers = Readonly<Record<Keyword, KeywordHandler>>
 
 export const elaborate = (
   program: SyntaxTree,
-  keywordModule: KeywordModule<`@${string}`>,
+  keywordHandlers: KeywordHandlers,
 ): Either<ElaborationError, ElaboratedSemanticGraph> =>
-  elaborateWithContext(program, keywordModule, {
+  elaborateWithContext(program, keywordHandlers, {
     location: [],
     program:
       typeof program === 'string'
@@ -51,19 +49,19 @@ export const elaborate = (
 
 export const elaborateWithContext = (
   program: SyntaxTree,
-  keywordModule: KeywordModule<`@${string}`>,
+  keywordHandlers: KeywordHandlers,
   context: ExpressionContext,
 ): Either<ElaborationError, ElaboratedSemanticGraph> =>
   either.map(
     typeof program === 'string'
       ? handleAtomWhichMayNotBeAKeyword(program)
-      : elaborateWithinMolecule(program, keywordModule, context),
+      : elaborateWithinMolecule(program, keywordHandlers, context),
     withPhantomData<Elaborated>(),
   )
 
 const elaborateWithinMolecule = (
   molecule: Molecule,
-  keywordModule: KeywordModule<`@${string}`>,
+  keywordHandlers: KeywordHandlers,
   context: ExpressionContext,
 ): Either<ElaborationError, SemanticGraph> => {
   const possibleExpressionAsObjectNode: Writable<ObjectNode> = makeObjectNode(
@@ -83,7 +81,7 @@ const elaborateWithinMolecule = (
       } else {
         const elaborationResult = elaborateWithinMolecule(
           value,
-          keywordModule,
+          keywordHandlers,
           {
             location: [...context.location, key],
             program: updatedProgram,
@@ -148,7 +146,7 @@ const elaborateWithinMolecule = (
             ...possibleExpressionAsObjectNode,
             0: possibleKeywordAsString,
           },
-          keywordModule,
+          keywordHandlers,
           {
             program: updatedProgram,
             location: context.location,
@@ -158,32 +156,29 @@ const elaborateWithinMolecule = (
   }
 }
 
-const handleObjectNodeWhichMayBeAExpression = <Keyword extends `@${string}`>(
+const handleObjectNodeWhichMayBeAExpression = (
   node: ObjectNode & { readonly 0: Atom },
-  keywordModule: KeywordModule<Keyword>,
+  keywordHandlers: KeywordHandlers,
   context: ExpressionContext,
 ): Either<ElaborationError, SemanticGraph> => {
   const { 0: possibleKeyword, ...possibleArguments } = node
-  return option.match(
-    option.fromPredicate(possibleKeyword, keywordModule.isKeyword),
-    {
-      none: () =>
-        /^@[^@]/.test(possibleKeyword)
-          ? either.makeLeft({
-              kind: 'unknownKeyword',
-              message: `unknown keyword: \`${possibleKeyword}\``,
-            })
-          : either.makeRight({
-              ...node,
-              0: unescapeKeywordSigil(possibleKeyword),
-            }),
-      some: keyword =>
-        keywordModule.handlers[keyword](
-          makeObjectNode({ ...possibleArguments, 0: keyword }),
-          context,
-        ),
-    },
-  )
+  return option.match(option.fromPredicate(possibleKeyword, isKeyword), {
+    none: () =>
+      /^@[^@]/.test(possibleKeyword)
+        ? either.makeLeft({
+            kind: 'unknownKeyword',
+            message: `unknown keyword: \`${possibleKeyword}\``,
+          })
+        : either.makeRight({
+            ...node,
+            0: unescapeKeywordSigil(possibleKeyword),
+          }),
+    some: keyword =>
+      keywordHandlers[keyword](
+        makeObjectNode({ ...possibleArguments, 0: keyword }),
+        context,
+      ),
+  })
 }
 
 const handleAtomWhichMayNotBeAKeyword = (

src/language/semantics/keyword.ts

@@ -0,0 +1,13 @@
+export const isKeyword = (input: string) =>
+  input === '@apply' ||
+  input === '@check' ||
+  input === '@function' ||
+  input === '@lookup' ||
+  input === '@runtime' ||
+  input === '@todo'
+
+export type Keyword = typeof isKeyword extends (
+  input: string,
+) => input is string & infer Keyword
+  ? Keyword
+  : never