Check for specific keyword while reading expressions

This fixes some more unparsing bugs.

Author: mkantor

src/language/compiling/unparsing.test.ts

@@ -59,6 +59,17 @@ testCases(
     },
     either.makeRight('(a => :a)("it works!")'),
   ],
+  [
+    {
+      0: '@runtime',
+      1: {
+        0: '@function',
+        parameter: 'context',
+        body: { 0: '@lookup', query: 'context.program.start_time' },
+      },
+    },
+    either.makeRight('{ @runtime, context => :context.program.start_time }'),
+  ],
 ])
 
 testCases(
@@ -108,6 +119,19 @@ testCases(
     },
     either.makeRight('(a => :a)("it works!")'),
   ],
+  [
+    {
+      0: '@runtime',
+      1: {
+        0: '@function',
+        parameter: 'context',
+        body: { 0: '@lookup', query: 'context.program.start_time' },
+      },
+    },
+    either.makeRight(
+      '{\n  @runtime\n  context => :context.program.start_time\n}',
+    ),
+  ],
 ])
 
 testCases(

src/language/semantics/expression.ts

@@ -9,3 +9,11 @@ export const isExpression = (
   node: SemanticGraph | Molecule,
 ): node is Expression =>
   typeof node === 'object' && typeof node[0] === 'string' && node[0][0] === '@'
+
+export const isSpecificExpression = <Keyword extends `@${string}`>(
+  keyword: Keyword,
+  node: SemanticGraph | Molecule,
+): node is {
+  readonly 0: Keyword
+} =>
+  typeof node === 'object' && typeof node[0] === 'string' && node[0] === keyword

src/language/semantics/expressions/apply-expression.ts

@@ -1,7 +1,7 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression } from '../expression.js'
+import { isSpecificExpression } from '../expression.js'
 import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import { type SemanticGraph, type unelaboratedKey } from '../semantic-graph.js'
 import { readArgumentsFromExpression } from './expression-utilities.js'
@@ -15,7 +15,7 @@ export type ApplyExpression = ObjectNode & {
 export const readApplyExpression = (
   node: SemanticGraph | Molecule,
 ): Either<ElaborationError, ApplyExpression> =>
-  isExpression(node)
+  isSpecificExpression('@apply', node)
     ? either.map(
         readArgumentsFromExpression(node, [
           ['function', '1'],

src/language/semantics/expressions/check-expression.ts

@@ -1,7 +1,7 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression } from '../expression.js'
+import { isSpecificExpression } from '../expression.js'
 import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import { type SemanticGraph, type unelaboratedKey } from '../semantic-graph.js'
 import { readArgumentsFromExpression } from './expression-utilities.js'
@@ -15,7 +15,7 @@ export type CheckExpression = ObjectNode & {
 export const readCheckExpression = (
   node: SemanticGraph | Molecule,
 ): Either<ElaborationError, CheckExpression> =>
-  isExpression(node)
+  isSpecificExpression('@check', node)
     ? either.map(
         readArgumentsFromExpression(node, [
           ['value', '1'],

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

@@ -1,7 +1,7 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError } from '../../errors.js'
 import type { Atom, Molecule } from '../../parsing.js'
-import { isExpression } from '../expression.js'
+import { isSpecificExpression } from '../expression.js'
 import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import {
   serialize,
@@ -22,7 +22,7 @@ export type FunctionExpression = ObjectNode & {
 export const readFunctionExpression = (
   node: SemanticGraph | Molecule,
 ): Either<ElaborationError, FunctionExpression> =>
-  isExpression(node)
+  isSpecificExpression('@function', node)
     ? either.flatMap(
         readArgumentsFromExpression(node, [
           ['parameter', '1'],

src/language/semantics/expressions/lookup-expression.ts

@@ -1,7 +1,7 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError, InvalidExpressionError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression } from '../expression.js'
+import { isSpecificExpression } from '../expression.js'
 import { isFunctionNode } from '../function-node.js'
 import { keyPathToMolecule, type KeyPath } from '../key-path.js'
 import {
@@ -23,7 +23,7 @@ export type LookupExpression = ObjectNode & {
 export const readLookupExpression = (
   node: SemanticGraph | Molecule,
 ): Either<ElaborationError, LookupExpression> =>
-  isExpression(node)
+  isSpecificExpression('@lookup', node)
     ? either.flatMap(
         readArgumentsFromExpression(node, [['query', '1']]),
         ([q]) => {

src/language/semantics/expressions/runtime-expression.ts

@@ -1,7 +1,7 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression } from '../expression.js'
+import { isSpecificExpression } from '../expression.js'
 import { isFunctionNode } from '../function-node.js'
 import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import {
@@ -22,7 +22,7 @@ export type RuntimeExpression = ObjectNode & {
 export const readRuntimeExpression = (
   node: SemanticGraph | Molecule,
 ): Either<ElaborationError, RuntimeExpression> =>
-  isExpression(node)
+  isSpecificExpression('@runtime', node)
     ? either.flatMap(
         readArgumentsFromExpression(node, [['function', '1']]),
         ([f]) => {