Prefer human-friendly property names in serializations

Author: mkantor

src/language/compiling/compiler.test.ts

@@ -66,7 +66,10 @@ testCases(compile, input => `compiling \`${JSON.stringify(input)}\``)(
     ],
     [
       ['@runtime', ['@lookup', ['identity']]],
-      success({ 0: '@runtime', 1: { 0: '@lookup', 1: { 0: 'identity' } } }),
+      success({
+        0: '@runtime',
+        function: { 0: '@lookup', query: { 0: 'identity' } },
+      }),
     ],
     [
       [
@@ -75,7 +78,7 @@ testCases(compile, input => `compiling \`${JSON.stringify(input)}\``)(
       ],
       success({
         0: '@runtime',
-        1: { 0: '@lookup', 1: { 0: 'identity' } },
+        function: { 0: '@lookup', query: { 0: 'identity' } },
       }),
     ],
     [
@@ -114,12 +117,12 @@ testCases(compile, input => `compiling \`${JSON.stringify(input)}\``)(
       ],
       success({
         0: '@runtime',
-        1: {
+        function: {
           0: '@apply',
-          1: { 0: '@lookup', 1: { 0: 'flow' } },
-          2: {
-            0: { 0: '@lookup', 1: { 0: 'identity' } },
-            1: { 0: '@lookup', 1: { 0: 'identity' } },
+          function: { 0: '@lookup', query: { 0: 'flow' } },
+          argument: {
+            0: { 0: '@lookup', query: { 0: 'identity' } },
+            1: { 0: '@lookup', query: { 0: 'identity' } },
           },
         },
       }),
@@ -154,8 +157,8 @@ testCases(compile, input => `compiling \`${JSON.stringify(input)}\``)(
         0: '@runtime',
         function: {
           0: '@apply',
-          1: { 0: '@lookup', 1: { 0: 'object', 1: 'lookup' } },
-          2: 'key which does not exist in runtime context',
+          function: { 0: '@lookup', query: { 0: 'object', 1: 'lookup' } },
+          argument: 'key which does not exist in runtime context',
         },
       }),
     ],

src/language/compiling/semantics.test.ts

@@ -586,7 +586,7 @@ elaborationSuite('@runtime', [
     { 0: '@runtime', 1: { 0: '@lookup', query: { 0: 'identity' } } },
     either.makeRight(
       withPhantomData<never>()(
-        makeObjectNode({ 0: '@runtime', 1: prelude.identity! }),
+        makeObjectNode({ 0: '@runtime', function: prelude.identity! }),
       ),
     ),
   ],

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

@@ -20,7 +20,6 @@ import {
 } from '../../../semantics/semantic-graph.js'
 import {
   asSemanticGraph,
-  locateSelf,
   readArgumentsFromExpression,
 } from './expression-utilities.js'
 
@@ -68,28 +67,25 @@ export const makeRuntimeExpression = (
 
 export const runtimeKeywordHandler: KeywordHandler = (
   expression: Expression,
-  context: ExpressionContext,
+  _context: ExpressionContext,
 ): Either<ElaborationError, SemanticGraph> =>
   either.flatMap(readRuntimeExpression(expression), ({ function: f }) => {
     const runtimeFunction = asSemanticGraph(f)
     if (isFunctionNode(runtimeFunction)) {
       const runtimeFunctionSignature = runtimeFunction.signature
-      return either.flatMap(locateSelf(context), valueFromProgram =>
-        !isAssignable({
-          source: types.runtimeContext,
-          target: replaceAllTypeParametersWithTheirConstraints(
-            runtimeFunctionSignature.parameter,
-          ),
-        })
-          ? either.makeLeft({
-              kind: 'typeMismatch',
-              message:
-                '@runtime function must accept a runtime context argument',
-            })
-          : either.makeRight(valueFromProgram),
-      )
+      return !isAssignable({
+        source: types.runtimeContext,
+        target: replaceAllTypeParametersWithTheirConstraints(
+          runtimeFunctionSignature.parameter,
+        ),
+      })
+        ? either.makeLeft({
+            kind: 'typeMismatch',
+            message: '@runtime function must accept a runtime context argument',
+          })
+        : either.makeRight(makeRuntimeExpression(f))
     } else {
       // TODO: Type-check unelaborated nodes.
-      return locateSelf(context)
+      return either.makeRight(makeRuntimeExpression(f))
     }
   })

src/language/compiling/semantics/prelude.ts

@@ -59,7 +59,7 @@ const preludeFunction = (
       either.makeRight(
         makeUnelaboratedObjectNode({
           0: '@lookup',
-          1: Object.fromEntries(keyPath.map((key, index) => [index, key])),
+          query: Object.fromEntries(keyPath.map((key, index) => [index, key])),
         }),
       ),
     option.none,
@@ -92,8 +92,8 @@ export const prelude: ObjectNode = makeObjectNode({
             either.map(serialize(argument), serializedArgument =>
               makeUnelaboratedObjectNode({
                 0: '@apply',
-                1: { 0: '@lookup', 1: { 0: 'apply' } },
-                2: serializedArgument,
+                function: { 0: '@lookup', query: { 0: 'apply' } },
+                argument: serializedArgument,
               }),
             ),
           option.none,
@@ -167,8 +167,8 @@ export const prelude: ObjectNode = makeObjectNode({
                   either.map(function1.serialize(), serializedFunction1 =>
                     makeUnelaboratedObjectNode({
                       0: '@apply',
-                      1: { 0: '@lookup', 1: { 0: 'flow' } },
-                      2: makeUnelaboratedObjectNode({
+                      function: { 0: '@lookup', query: { 0: 'flow' } },
+                      argument: makeUnelaboratedObjectNode({
                         0: serializedFunction0,
                         1: serializedFunction1,
                       }),
@@ -245,8 +245,8 @@ export const prelude: ObjectNode = makeObjectNode({
               either.map(serializeObjectNode(cases), serializedCases =>
                 makeUnelaboratedObjectNode({
                   0: '@apply',
-                  1: { 0: '@lookup', 1: { 0: 'match' } },
-                  2: serializedCases,
+                  function: { 0: '@lookup', query: { 0: 'match' } },
+                  argument: serializedCases,
                 }),
               ),
             option.none,
@@ -305,8 +305,11 @@ export const prelude: ObjectNode = makeObjectNode({
                 either.makeRight(
                   makeUnelaboratedObjectNode({
                     0: '@apply',
-                    1: { 0: '@lookup', 1: { 0: 'object', 1: 'lookup' } },
-                    2: key,
+                    function: {
+                      0: '@lookup',
+                      query: { 0: 'object', 1: 'lookup' },
+                    },
+                    argument: key,
                   }),
                 ),
               option.none,