Use generalized keyword expression sugar in unparsers

Author: mkantor

src/language/compiling/unparsing.test.ts

@@ -86,9 +86,7 @@ testCases(
         },
       },
     },
-    either.makeRight(
-      '{ "@runtime", { context => :context.program.start_time } }',
-    ),
+    either.makeRight('@runtime { context => :context.program.start_time }'),
   ],
   [
     {
@@ -182,9 +180,7 @@ testCases(
         },
       },
     },
-    either.makeRight(
-      '{\n  "@runtime"\n  {\n    context => :context.program.start_time\n  }\n}',
-    ),
+    either.makeRight('@runtime {\n  context => :context.program.start_time\n}'),
   ],
   [
     {

src/language/unparsing/plz-utilities.ts

@@ -5,13 +5,15 @@ import type { UnserializableValueError } from '../errors.js'
 import type { Atom, Molecule } from '../parsing.js'
 import { unquotedAtomParser } from '../parsing/atom.js'
 import {
+  isExpression,
   isSemanticGraph,
   readApplyExpression,
   readFunctionExpression,
   readIndexExpression,
   readLookupExpression,
   serialize,
   type ApplyExpression,
+  type Expression,
   type FunctionExpression,
   type IndexExpression,
   type KeyPath,
@@ -55,7 +57,19 @@ export const moleculeUnparser =
             unparseSugaredLookup(lookupExpression, unparseAtomOrMolecule),
         })
       default:
-        return unparseSugarFreeMolecule(value, unparseAtomOrMolecule)
+        if (isExpression(value)) {
+          const result = unparseSugaredGeneralizedKeywordExpression(
+            value,
+            unparseAtomOrMolecule,
+          )
+          if (either.isLeft(result)) {
+            return unparseSugarFreeMolecule(value, unparseAtomOrMolecule)
+          } else {
+            return result
+          }
+        } else {
+          return unparseSugarFreeMolecule(value, unparseAtomOrMolecule)
+        }
     }
   }
 
@@ -101,10 +115,12 @@ export const unparseAtom = (atom: string): Right<string> =>
       : quoteAtomIfNecessary(atom),
   )
 
+const requiresQuotation = (atom: string): boolean =>
+  either.isLeft(parsing.parse(unquotedAtomParser, atom))
+
 const quoteAtomIfNecessary = (value: string): string => {
   const { quote } = punctuation(kleur)
-  const unquotedAtomResult = parsing.parse(unquotedAtomParser, value)
-  if (either.isLeft(unquotedAtomResult)) {
+  if (requiresQuotation(value)) {
     return quote.concat(escapeStringContents(value)).concat(quote)
   } else {
     return value
@@ -252,3 +268,38 @@ const unparseSugaredLookup = (
       ),
     ),
   )
+
+const unparseSugaredGeneralizedKeywordExpression = (
+  expression: Expression,
+  unparseAtomOrMolecule: UnparseAtomOrMolecule,
+) => {
+  if (
+    // Not every valid keyword expression can be expressed with the
+    // generalized sugar, e.g. if there are any additional properties
+    // besides the keyword and its argument, or if the keyword requires
+    // quotation (which won't be the case for any built-in keywords, but
+    // maybe eventually users will be able to create custom keywords).
+    requiresQuotation(expression['0'].substring(1)) ||
+    Object.keys(expression).some(key => key !== '0' && key !== '1')
+  ) {
+    return either.makeLeft({
+      kind: 'unserializableValue',
+      message:
+        'expression cannot be faithfully represented using generalized keyword expression sugar',
+    })
+  } else {
+    const unparsedKeyword = kleur.bold(kleur.underline(expression['0']))
+    if ('1' in expression) {
+      return either.map(
+        either.flatMap(
+          serializeIfNeeded(expression['1']),
+          unparseAtomOrMolecule,
+        ),
+        unparsedArgument =>
+          unparsedKeyword.concat(' ').concat(unparsedArgument),
+      )
+    } else {
+      return either.makeRight(unparsedKeyword)
+    }
+  }
+}