Extract keyPathToMolecule function

Author: mkantor

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

@@ -10,7 +10,10 @@ import {
   type ExpressionContext,
   type KeywordHandler,
 } from '../../../semantics/expression-elaboration.js'
-import { stringifyKeyPathForEndUser } from '../../../semantics/key-path.js'
+import {
+  keyPathToMolecule,
+  stringifyKeyPathForEndUser,
+} from '../../../semantics/key-path.js'
 import {
   isObjectNode,
   makeObjectNode,
@@ -52,11 +55,7 @@ export const readLookupExpression = (
           } else {
             const canonicalizedQuery =
               typeof query === 'string'
-                ? makeObjectNode(
-                    Object.fromEntries(
-                      query.split('.').map((key, index) => [index, key]),
-                    ),
-                  )
+                ? makeObjectNode(keyPathToMolecule(query.split('.')))
                 : query
 
             return either.map(
@@ -212,11 +211,7 @@ const lookup = ({
                   return either.makeRight(
                     option.makeSome(
                       makeLookupExpression(
-                        makeObjectNode(
-                          Object.fromEntries(
-                            relativePath.map((key, index) => [index, key]),
-                          ),
-                        ),
+                        makeObjectNode(keyPathToMolecule(relativePath)),
                       ),
                     ),
                   )

src/language/compiling/semantics/prelude.ts

@@ -9,6 +9,7 @@ import {
   types,
   type ObjectNode,
 } from '../../semantics.js'
+import { keyPathToMolecule } from '../../semantics/key-path.js'
 import {
   lookupPropertyOfObjectNode,
   makeUnelaboratedObjectNode,
@@ -60,7 +61,7 @@ const preludeFunction = (
       either.makeRight(
         makeUnelaboratedObjectNode({
           0: '@lookup',
-          query: Object.fromEntries(keyPath.map((key, index) => [index, key])),
+          query: keyPathToMolecule(keyPath),
         }),
       ),
     option.none,

src/language/semantics/key-path.ts

@@ -1,4 +1,4 @@
-import type { Atom } from '../parsing.js'
+import type { Atom, Molecule } from '../parsing.js'
 
 export const functionParameter = Symbol('functionParameter')
 export const functionReturn = Symbol('functionReturn')
@@ -7,10 +7,19 @@ export const typeParameterAssignableToConstraint = Symbol(
 )
 export type KeyPath = readonly (
   | Atom
+  // These symbol keys are somewhat "internal" at the moment. If they end up not being expressible
+  // in the surface syntax then `KeyPath` should be split into two separate types.
   | typeof functionParameter
   | typeof functionReturn
   | typeof typeParameterAssignableToConstraint
 )[]
 
 export const stringifyKeyPathForEndUser = (keyPath: KeyPath): string =>
   JSON.stringify(keyPath)
+
+export const keyPathToMolecule = (keyPath: KeyPath): Molecule =>
+  Object.fromEntries(
+    keyPath.flatMap((key, index) =>
+      typeof key === 'symbol' ? [] : [[index, key]],
+    ),
+  )