Move some expression stuff out of the compiler

Author: mkantor

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

@@ -1,10 +1,9 @@
 import { either, type Either } from '../../../../adts.js'
 import type { ElaborationError } from '../../../errors.js'
-import type { Molecule } from '../../../parsing.js'
 import {
-  isExpression,
+  asSemanticGraph,
   isFunctionNode,
-  makeUnelaboratedObjectNode,
+  readApplyExpression,
   type Expression,
 } from '../../../semantics.js'
 import {
@@ -14,49 +13,7 @@ import {
 import {
   containsAnyUnelaboratedNodes,
   type SemanticGraph,
-  type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
-import {
-  asSemanticGraph,
-  readArgumentsFromExpression,
-} from './expression-utilities.js'
-
-export const applyKeyword = '@apply'
-
-export type ApplyExpression = Expression & {
-  readonly 0: '@apply'
-  readonly function: SemanticGraph | Molecule
-  readonly argument: SemanticGraph | Molecule
-}
-
-export const readApplyExpression = (
-  node: SemanticGraph,
-): Either<ElaborationError, ApplyExpression> =>
-  isExpression(node)
-    ? either.map(
-        readArgumentsFromExpression(node, [
-          ['function', '1'],
-          ['argument', '2'],
-        ]),
-        ([f, argument]) => makeApplyExpression({ function: f, argument }),
-      )
-    : either.makeLeft({
-        kind: 'invalidExpression',
-        message: 'not an expression',
-      })
-
-export const makeApplyExpression = ({
-  function: f,
-  argument,
-}: {
-  readonly function: SemanticGraph | Molecule
-  readonly argument: SemanticGraph | Molecule
-}): ApplyExpression & { readonly [unelaboratedKey]: true } =>
-  makeUnelaboratedObjectNode({
-    0: '@apply',
-    function: f,
-    argument,
-  })
 
 export const applyKeywordHandler: KeywordHandler = (
   expression: Expression,

…emantics/expressions/apply-expression.ts …antics/keyword-handlers/apply-handler.tssrc/language/compiling/semantics/expressions/apply-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/apply-handler.ts src/language/compiling/semantics/expressions/apply-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/apply-handler.ts

@@ -1,10 +1,9 @@
 import { either, option, type Either } from '../../../../adts.js'
 import type { ElaborationError } from '../../../errors.js'
-import type { Molecule } from '../../../parsing.js'
 import {
-  isExpression,
+  asSemanticGraph,
   isFunctionNode,
-  makeUnelaboratedObjectNode,
+  readCheckExpression,
   type Expression,
 } from '../../../semantics.js'
 import {
@@ -15,49 +14,7 @@ import { lookupPropertyOfObjectNode } from '../../../semantics/object-node.js'
 import {
   stringifySemanticGraphForEndUser,
   type SemanticGraph,
-  type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
-import {
-  asSemanticGraph,
-  readArgumentsFromExpression,
-} from './expression-utilities.js'
-
-export const checkKeyword = '@check'
-
-export type CheckExpression = Expression & {
-  readonly 0: '@check'
-  readonly value: SemanticGraph | Molecule
-  readonly type: SemanticGraph | Molecule
-}
-
-export const readCheckExpression = (
-  node: SemanticGraph,
-): Either<ElaborationError, CheckExpression> =>
-  isExpression(node)
-    ? either.map(
-        readArgumentsFromExpression(node, [
-          ['value', '1'],
-          ['type', '2'],
-        ]),
-        ([value, type]) => makeCheckExpression({ value, type }),
-      )
-    : either.makeLeft({
-        kind: 'invalidExpression',
-        message: 'not an expression',
-      })
-
-export const makeCheckExpression = ({
-  value,
-  type,
-}: {
-  value: SemanticGraph | Molecule
-  type: SemanticGraph | Molecule
-}): CheckExpression & { readonly [unelaboratedKey]: true } =>
-  makeUnelaboratedObjectNode({
-    0: '@check',
-    value,
-    type,
-  })
 
 export const checkKeywordHandler: KeywordHandler = (
   expression: Expression,

…emantics/expressions/check-expression.ts …antics/keyword-handlers/check-handler.tssrc/language/compiling/semantics/expressions/check-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/check-handler.ts src/language/compiling/semantics/expressions/check-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/check-handler.ts

@@ -1,13 +1,13 @@
 import { either, option, type Either } from '../../../../adts.js'
 import type { ElaborationError } from '../../../errors.js'
-import type { Atom, Molecule } from '../../../parsing.js'
 import {
-  isExpression,
+  asSemanticGraph,
   makeFunctionNode,
-  makeUnelaboratedObjectNode,
+  readFunctionExpression,
   serialize,
   types,
   type Expression,
+  type FunctionExpression,
   type FunctionNode,
 } from '../../../semantics.js'
 import {
@@ -19,55 +19,8 @@ import { makeObjectNode } from '../../../semantics/object-node.js'
 import {
   updateValueAtKeyPathInSemanticGraph,
   type SemanticGraph,
-  type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
 import { keywordHandlers } from '../keywords.js'
-import {
-  asSemanticGraph,
-  readArgumentsFromExpression,
-} from './expression-utilities.js'
-
-export const functionKeyword = '@function'
-
-export type FunctionExpression = Expression & {
-  readonly 0: '@function'
-  readonly parameter: Atom
-  readonly body: SemanticGraph | Molecule
-}
-
-export const readFunctionExpression = (
-  node: SemanticGraph,
-): Either<ElaborationError, FunctionExpression> =>
-  isExpression(node)
-    ? either.flatMap(
-        readArgumentsFromExpression(node, [
-          ['parameter', '1'],
-          ['body', '2'],
-        ]),
-        ([parameter, body]): Either<ElaborationError, FunctionExpression> =>
-          typeof parameter !== 'string'
-            ? either.makeLeft({
-                kind: 'invalidExpression',
-                message: 'parameter name must be an atom',
-              })
-            : either.map(serialize(asSemanticGraph(body)), body =>
-                makeFunctionExpression(parameter, body),
-              ),
-      )
-    : either.makeLeft({
-        kind: 'invalidExpression',
-        message: 'not an expression',
-      })
-
-export const makeFunctionExpression = (
-  parameter: Atom,
-  body: SemanticGraph | Molecule,
-): FunctionExpression & { readonly [unelaboratedKey]: true } =>
-  makeUnelaboratedObjectNode({
-    0: '@function',
-    parameter,
-    body,
-  })
 
 export const functionKeywordHandler: KeywordHandler = (
   expression: Expression,

…ntics/expressions/function-expression.ts …ics/keyword-handlers/function-handler.tssrc/language/compiling/semantics/expressions/function-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/function-handler.ts src/language/compiling/semantics/expressions/function-expression.ts renamed to src/language/compiling/semantics/keyword-handlers/function-handler.ts

@@ -4,8 +4,9 @@ import type {
   InvalidExpressionError,
 } from '../../../errors.js'
 import {
-  isExpression,
-  isFunctionNode,
+  makeLookupExpression,
+  readFunctionExpression,
+  readLookupExpression,
   type Expression,
   type KeyPath,
 } from '../../../semantics.js'
@@ -20,66 +21,13 @@ import {
 import {
   isObjectNode,
   makeObjectNode,
-  makeUnelaboratedObjectNode,
   type ObjectNode,
 } from '../../../semantics/object-node.js'
 import {
   applyKeyPathToSemanticGraph,
   type SemanticGraph,
-  type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
 import { prelude } from '../prelude.js'
-import {
-  asSemanticGraph,
-  readArgumentsFromExpression,
-} from './expression-utilities.js'
-import { readFunctionExpression } from './function-expression.js'
-
-export const lookupKeyword = '@lookup'
-
-export type LookupExpression = Expression & {
-  readonly 0: '@lookup'
-  readonly query: ObjectNode
-}
-
-export const readLookupExpression = (
-  node: SemanticGraph,
-): Either<ElaborationError, LookupExpression> =>
-  isExpression(node)
-    ? either.flatMap(
-        readArgumentsFromExpression(node, [['query', '1']]),
-        ([q]) => {
-          const query = asSemanticGraph(q)
-          if (isFunctionNode(query)) {
-            return either.makeLeft({
-              kind: 'invalidExpression',
-              message: 'query cannot be a function',
-            })
-          } else {
-            const canonicalizedQuery =
-              typeof query === 'string'
-                ? makeObjectNode(keyPathToMolecule(query.split('.')))
-                : query
-
-            return either.map(
-              keyPathFromObjectNode(canonicalizedQuery),
-              _keyPath => makeLookupExpression(canonicalizedQuery),
-            )
-          }
-        },
-      )
-    : either.makeLeft({
-        kind: 'invalidExpression',
-        message: 'not an expression',
-      })
-
-export const makeLookupExpression = (
-  query: ObjectNode,
-): LookupExpression & { readonly [unelaboratedKey]: true } =>
-  makeUnelaboratedObjectNode({
-    0: '@lookup',
-    query,
-  })
 
 export const lookupKeywordHandler: KeywordHandler = (
   expression: Expression,