Implement @if keyword expression

Author: mkantor

src/end-to-end.test.ts

@@ -264,4 +264,13 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     }`,
     either.makeRight({ true: 'true', false: 'false' }),
   ],
+  [
+    `{@runtime context =>
+      {@if :boolean.not(:boolean.is(:context))
+        "it works!"
+        {@panic}
+      }
+    }`,
+    either.makeRight('it works!'),
+  ],
 ])

src/language/compiling/semantics/keyword-handlers/if-handler.test.ts

@@ -0,0 +1,82 @@
+import { elaborationSuite, success } from '../test-utilities.test.js'
+
+elaborationSuite('@if', [
+  [{ 0: '@if', condition: 'false', then: 'no', else: 'yes' }, success('yes')],
+  [{ 0: '@if', condition: 'true', then: 'yes', else: 'no' }, success('yes')],
+  [
+    {
+      0: '@if',
+      condition: 'true',
+      then: 'it works!',
+      else: { 0: '@panic' },
+    },
+    success('it works!'),
+  ],
+  [
+    {
+      a: 'it works!',
+      b: {
+        0: '@if',
+        condition: 'true',
+        then: { 0: '@lookup', key: 'a' },
+        else: { 0: '@panic' },
+      },
+    },
+    success({ a: 'it works!', b: 'it works!' }),
+  ],
+  [
+    {
+      0: '@if',
+      condition: 'false',
+      then: { 0: '@panic' },
+      else: 'it works!',
+    },
+    success('it works!'),
+  ],
+  [
+    {
+      0: '@if',
+      condition: {
+        0: '@apply',
+        function: {
+          0: '@index',
+          object: { 0: '@lookup', key: 'boolean' },
+          query: { 0: 'not' },
+        },
+        argument: 'false',
+      },
+      then: 'it works!',
+      else: { 0: '@panic' },
+    },
+    success('it works!'),
+  ],
+  [
+    {
+      0: '@if',
+      1: {
+        0: '@apply',
+        function: {
+          0: '@index',
+          object: { 0: '@lookup', key: 'boolean' },
+          query: { 0: 'not' },
+        },
+        argument: 'false',
+      },
+      2: 'it works!',
+      3: { 0: '@panic' },
+    },
+    success('it works!'),
+  ],
+  [
+    {
+      a: {
+        0: '@if',
+        condition: { 0: '@lookup', key: 'b' },
+        then: 'it works!',
+        else: { 0: '@panic' },
+      },
+      b: 'true',
+    },
+    success({ a: 'it works!', b: 'true' }),
+  ],
+])

src/language/compiling/semantics/keyword-handlers/if-handler.ts

@@ -1,14 +1,91 @@
 import either, { type Either } from '@matt.kantor/either'
 import type { ElaborationError } from '../../../errors.js'
+import type { Molecule } from '../../../parsing.js'
 import {
+  asSemanticGraph,
+  containsAnyUnelaboratedNodes,
+  elaborateWithContext,
+  makeIfExpression,
+  readIfExpression,
+  serialize,
   type Expression,
   type ExpressionContext,
   type KeywordHandler,
   type SemanticGraph,
 } from '../../../semantics.js'
 
 export const ifKeywordHandler: KeywordHandler = (
-  _expression: Expression,
-  _context: ExpressionContext,
+  expression: Expression,
+  context: ExpressionContext,
 ): Either<ElaborationError, SemanticGraph> =>
-  either.makeLeft({ kind: 'bug', message: 'not implemented' })
+  either.flatMap(readIfExpression(expression), ifExpression => {
+    const expressionKeys = {
+      // Note: this must be kept in alignment with `readIfExpression`.
+      condition: 'condition' in expression ? 'condition' : '1',
+      then: 'then' in expression ? 'then' : '2',
+      else: 'else' in expression ? 'else' : '3',
+    }
+
+    const elaboratedCondition = evaluateSubexpression(
+      expressionKeys.condition,
+      context,
+      ifExpression.condition,
+    )
+
+    return either.flatMap(elaboratedCondition, elaboratedCondition => {
+      if (elaboratedCondition === 'true') {
+        return either.map(
+          evaluateSubexpression(
+            expressionKeys.then,
+            context,
+            ifExpression.then,
+          ),
+          asSemanticGraph,
+        )
+      } else if (elaboratedCondition === 'false') {
+        return either.map(
+          evaluateSubexpression(
+            expressionKeys.else,
+            context,
+            ifExpression.else,
+          ),
+          asSemanticGraph,
+        )
+      } else {
+        return either.flatMap(
+          serialize(elaboratedCondition),
+          elaboratedCondition => {
+            if (containsAnyUnelaboratedNodes(elaboratedCondition)) {
+              // Return an unelaborated `@if` expression.
+              return either.makeRight(
+                makeIfExpression({
+                  ...ifExpression,
+                  condition: elaboratedCondition,
+                }),
+              )
+            } else {
+              return either.makeLeft({
+                kind: 'invalidExpression',
+                message: 'condition was not boolean',
+              })
+            }
+          },
+        )
+      }
+    })
+  })
+
+const evaluateSubexpression = (
+  key: string,
+  context: ExpressionContext,
+  subexpression: SemanticGraph | Molecule,
+) =>
+  either.flatMap(
+    serialize(asSemanticGraph(subexpression)),
+    serializedSubexpression =>
+      elaborateWithContext(serializedSubexpression, {
+        keywordHandlers: context.keywordHandlers,
+        program: context.program,
+        location: [...context.location, key],
+      }),
+  )

src/language/semantics.ts

@@ -27,6 +27,11 @@ export {
   readFunctionExpression,
   type FunctionExpression,
 } from './semantics/expressions/function-expression.js'
+export {
+  makeIfExpression,
+  readIfExpression,
+  type IfExpression,
+} from './semantics/expressions/if-expression.js'
 export {
   makeIndexExpression,
   readIndexExpression,