Eliminate a redundant function

Author: mkantor

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

@@ -19,7 +19,7 @@ import {
   makeUnelaboratedObjectNode,
 } from '../../../semantics/object-node.js'
 import {
-  updateValueAtKeyPathInSemanticGraphIfValid,
+  updateValueAtKeyPathInSemanticGraph,
   type SemanticGraph,
   type unelaboratedKey,
 } from '../../../semantics/semantic-graph.js'
@@ -102,27 +102,30 @@ const apply = (
       ? 'return with a different key to avoid collision with a stupidly-named parameter'
       : 'return'
 
-  const result = either.flatMap(serialize(body), serializedBody => {
-    const updatedProgram = updateValueAtKeyPathInSemanticGraphIfValid(
-      context.program,
-      context.location,
-      _ =>
-        makeObjectNode({
-          // Put the argument in scope.
-          [expression.parameter]: argument,
-          [returnKey]: body,
-        }),
-    )
+  const result = either.flatMap(serialize(body), serializedBody =>
+    either.flatMap(
+      updateValueAtKeyPathInSemanticGraph(
+        context.program,
+        context.location,
+        _ =>
+          makeObjectNode({
+            // Put the argument in scope.
+            [expression.parameter]: argument,
+            [returnKey]: body,
+          }),
+      ),
+      updatedProgram =>
+        elaborateWithContext(
+          serializedBody,
+          { handlers, isKeyword },
+          {
+            location: [...context.location, returnKey],
+            program: updatedProgram,
+          },
+        ),
+    ),
+  )
 
-    return elaborateWithContext(
-      serializedBody,
-      { handlers, isKeyword },
-      {
-        location: [...context.location, returnKey],
-        program: updatedProgram,
-      },
-    )
-  })
   if (either.isLeft(result)) {
     return either.makeLeft({
       kind: 'panic',

src/language/semantics/semantic-graph.ts

@@ -9,7 +9,6 @@ import type { Canonicalized } from '../parsing/syntax-tree.js'
 import { serializeFunctionNode, type FunctionNode } from './function-node.js'
 import { stringifyKeyPathForEndUser, type KeyPath } from './key-path.js'
 import {
-  lookupPropertyOfObjectNode,
   makeObjectNode,
   makeUnelaboratedObjectNode,
   serializeObjectNode,
@@ -52,43 +51,6 @@ export const applyKeyPathToSemanticGraph = (
   }
 }
 
-export const updateValueAtKeyPathInSemanticGraphIfValid = (
-  value: SemanticGraph,
-  keyPath: KeyPath,
-  operation: (valueAtKeyPath: SemanticGraph) => SemanticGraph,
-): SemanticGraph => {
-  const [firstKey, ...remainingKeyPath] = keyPath
-  if (firstKey === undefined) {
-    // If the key path is empty, this is the value to operate on.
-    return operation(value)
-  } else {
-    return matchSemanticGraph(value, {
-      atom: (node): SemanticGraph => node,
-      function: node => node,
-      object: node => {
-        if (typeof firstKey === 'string') {
-          return option.match(lookupPropertyOfObjectNode(firstKey, node), {
-            none: () => node,
-            some: propertyValue =>
-              (isUnelaborated(node)
-                ? makeUnelaboratedObjectNode
-                : makeObjectNode)({
-                ...node,
-                [firstKey]: updateValueAtKeyPathInSemanticGraphIfValid(
-                  propertyValue,
-                  remainingKeyPath,
-                  operation,
-                ),
-              }),
-          })
-        } else {
-          return node
-        }
-      },
-    })
-  }
-}
-
 export const isUnelaborated = (node: SemanticGraph | Molecule): boolean =>
   typeof node !== 'string' &&
   unelaboratedKey in node &&