Generalize some expression utilities to accept molecules

Author: mkantor

src/language/runtime/keywords.ts

@@ -13,7 +13,10 @@ import {
   type KeywordHandlers,
   type SemanticGraph,
 } from '../semantics.js'
-import { lookupPropertyOfObjectNode } from '../semantics/object-node.js'
+import {
+  lookupPropertyOfObjectNode,
+  makeUnelaboratedObjectNode,
+} from '../semantics/object-node.js'
 
 const unserializableFunction = () =>
   either.makeLeft({
@@ -164,7 +167,10 @@ const lookupWithinExpression = (
   expression: Expression,
 ): Option<SemanticGraph> => {
   for (const key of keyAliases) {
-    const result = lookupPropertyOfObjectNode(key, expression)
+    const result = lookupPropertyOfObjectNode(
+      key,
+      makeUnelaboratedObjectNode(expression),
+    )
     if (!option.isNone(result)) {
       return result
     }

src/language/semantics/expression.ts

@@ -1,8 +1,11 @@
-import type { ObjectNode, SemanticGraph } from '../semantics.js'
+import type { Molecule } from '../parsing.js'
+import type { SemanticGraph } from './semantic-graph.js'
 
-export type Expression = ObjectNode & {
+export type Expression = {
   readonly 0: `@${string}`
 }
 
-export const isExpression = (node: SemanticGraph): node is Expression =>
+export const isExpression = (
+  node: SemanticGraph | Molecule,
+): node is Expression =>
   typeof node === 'object' && typeof node[0] === 'string' && node[0][0] === '@'

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

@@ -1,19 +1,19 @@
 import { either, type Either } from '../../../adts.js'
 import type { ElaborationError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression, type Expression } from '../expression.js'
-import { makeUnelaboratedObjectNode } from '../object-node.js'
+import { isExpression } 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'
 
-export type ApplyExpression = Expression & {
+export type ApplyExpression = ObjectNode & {
   readonly 0: '@apply'
   readonly function: SemanticGraph | Molecule
   readonly argument: SemanticGraph | Molecule
 }
 
 export const readApplyExpression = (
-  node: SemanticGraph,
+  node: SemanticGraph | Molecule,
 ): Either<ElaborationError, ApplyExpression> =>
   isExpression(node)
     ? either.map(

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

@@ -1,19 +1,19 @@
 import { either, type Either } from '../../../adts.js'
 import type { ElaborationError } from '../../errors.js'
 import type { Molecule } from '../../parsing.js'
-import { isExpression, type Expression } from '../expression.js'
-import { makeUnelaboratedObjectNode } from '../object-node.js'
+import { isExpression } 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'
 
-export type CheckExpression = Expression & {
+export type CheckExpression = ObjectNode & {
   readonly 0: '@check'
   readonly value: SemanticGraph | Molecule
   readonly type: SemanticGraph | Molecule
 }
 
 export const readCheckExpression = (
-  node: SemanticGraph,
+  node: SemanticGraph | Molecule,
 ): Either<ElaborationError, CheckExpression> =>
   isExpression(node)
     ? either.map(

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

@@ -72,7 +72,10 @@ const lookupWithinExpression = (
   expression: Expression,
 ): Option<SemanticGraph> => {
   for (const key of keyAliases) {
-    const result = lookupPropertyOfObjectNode(key, expression)
+    const result = lookupPropertyOfObjectNode(
+      key,
+      makeUnelaboratedObjectNode(expression),
+    )
     if (!option.isNone(result)) {
       return result
     }

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

@@ -1,8 +1,8 @@
 import { either, type Either } from '../../../adts.js'
 import type { ElaborationError } from '../../errors.js'
 import type { Atom, Molecule } from '../../parsing.js'
-import { isExpression, type Expression } from '../expression.js'
-import { makeUnelaboratedObjectNode } from '../object-node.js'
+import { isExpression } from '../expression.js'
+import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import {
   serialize,
   type SemanticGraph,
@@ -13,14 +13,14 @@ import {
   readArgumentsFromExpression,
 } from './expression-utilities.js'
 
-export type FunctionExpression = Expression & {
+export type FunctionExpression = ObjectNode & {
   readonly 0: '@function'
   readonly parameter: Atom
   readonly body: SemanticGraph | Molecule
 }
 
 export const readFunctionExpression = (
-  node: SemanticGraph,
+  node: SemanticGraph | Molecule,
 ): Either<ElaborationError, FunctionExpression> =>
   isExpression(node)
     ? either.flatMap(

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

@@ -1,6 +1,7 @@
 import { either, type Either } from '../../../adts.js'
 import type { ElaborationError, InvalidExpressionError } from '../../errors.js'
-import { isExpression, type Expression } from '../expression.js'
+import type { Molecule } from '../../parsing.js'
+import { isExpression } from '../expression.js'
 import { isFunctionNode } from '../function-node.js'
 import { keyPathToMolecule, type KeyPath } from '../key-path.js'
 import {
@@ -14,13 +15,13 @@ import {
   readArgumentsFromExpression,
 } from './expression-utilities.js'
 
-export type LookupExpression = Expression & {
+export type LookupExpression = ObjectNode & {
   readonly 0: '@lookup'
   readonly query: ObjectNode
 }
 
 export const readLookupExpression = (
-  node: SemanticGraph,
+  node: SemanticGraph | Molecule,
 ): Either<ElaborationError, LookupExpression> =>
   isExpression(node)
     ? either.flatMap(

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

@@ -1,8 +1,9 @@
 import { either, type Either } from '../../../adts.js'
 import type { ElaborationError } from '../../errors.js'
-import { isExpression, type Expression } from '../expression.js'
+import type { Molecule } from '../../parsing.js'
+import { isExpression } from '../expression.js'
 import { isFunctionNode } from '../function-node.js'
-import { makeUnelaboratedObjectNode } from '../object-node.js'
+import { makeUnelaboratedObjectNode, type ObjectNode } from '../object-node.js'
 import {
   containsAnyUnelaboratedNodes,
   type SemanticGraph,
@@ -13,13 +14,13 @@ import {
   readArgumentsFromExpression,
 } from './expression-utilities.js'
 
-export type RuntimeExpression = Expression & {
+export type RuntimeExpression = ObjectNode & {
   readonly 0: '@runtime'
   readonly function: SemanticGraph
 }
 
 export const readRuntimeExpression = (
-  node: SemanticGraph,
+  node: SemanticGraph | Molecule,
 ): Either<ElaborationError, RuntimeExpression> =>
   isExpression(node)
     ? either.flatMap(

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

@@ -1,5 +1,5 @@
-import { type Expression } from '../expression.js'
+import type { ObjectNode } from '../object-node.js'
 
-export type TodoExpression = Expression & {
+export type TodoExpression = ObjectNode & {
   readonly 0: '@todo'
 }