Make infix expressions right-associative

Author: mkantor

README.md

@@ -172,24 +172,29 @@ example, the expression `x f y` desugars to `:f(y)(x)`. Here's another example:
 ```
 {
   cons: b => a => { :a, :b }
-  list: 1 cons (2 cons 3) // evaluates to `{ 1, { 2, 3 } }`
+  list: 1 cons 2 cons 3 // evaluates to `{ 1, { 2, 3 } }`
 }
 ```
 
 The standard library contains symbolically-named functions for arithmetic and
-other familiar binary operations. For example, `1 + 2 - 3` is `0`. Also
-included in the standard library are the functions`|>` (pipe) and `>>` (flow):
+other familiar binary operations. For example, `1 + 2 - 3` is `0`. Also included
+in the standard library are the functions`|>` (pipe) and `>>` (flow):
 
 ```
 {
-  // `>>` composes functions from left to right
+  // `>>` composes functions
   append_bc: :atom.append(b) >> :atom.append(c)
 
   // `|>` pipes an argument into a function
   abc: a |> :append_bc
 }
 ```
 
+All binary operations are currently right-associative and there is no operator
+precedence. This means some arithmetic expressions may not behave the way you're
+used to; for example `1 - 2 - 3` means `1 - (2 - 3)` (2), not `(1 - 2) - 3`
+(-4). Use of parentheses is encouraged.
+
 ### Semantics
 
 Please is a functional programming language. Currently all functions are pure,

src/end-to-end.test.ts

@@ -168,6 +168,14 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   [`:integer.subtract(-1)(-1)`, either.makeRight('0')],
   [`-1 - -1`, either.makeRight('0')],
   [`2 - 1`, either.makeRight('1')],
+  [
+    `1 - 2 - 3`,
+    either.makeRight(
+      '2', // with traditional operator associativity this would be `-4`
+    ),
+  ],
+  [`1 - (2 - 3)`, either.makeRight('2')],
+  [`(1 - 2) - 3`, either.makeRight('-4')],
   [':flow(:atom.append(b))(:atom.append(a))(z)', either.makeRight('zab')],
   [
     `{@runtime
@@ -314,7 +322,8 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   [`(a => (1 + :a))(1)`, either.makeRight('2')],
   [`2 |> (a => :a)`, either.makeRight('2')],
   [`a atom.append b atom.append c`, either.makeRight('abc')],
-  [`b atom.append c atom.prepend a`, either.makeRight('abc')],
+  [`a atom.append c atom.prepend b`, either.makeRight('abc')],
+  [`(b atom.append c) atom.prepend a`, either.makeRight('abc')],
   [`a atom.append (c atom.prepend b)`, either.makeRight('abc')],
   [
     `1
@@ -336,7 +345,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
       (
         PATH
           |> :context.environment.lookup
-          |> :match({
+          >> :match({
             none: _ => "$PATH not set"
             some: :atom.prepend("PATH=")
           })
@@ -376,13 +385,14 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     )(0)`,
     either.makeRight('10'),
   ],
-  [`a |> :atom.append(b) |> :atom.append(c)`, either.makeRight('abc')],
-  [`a |> (:atom.append(b) >> :atom.append(c))`, either.makeRight('abc')],
+  [`a |> :atom.append(b) >> :atom.append(c)`, either.makeRight('abc')],
+  [`(a |> :atom.append(b)) |> :atom.append(c)`, either.makeRight('abc')],
   [`:|>(:>>(:atom.append(c))(:atom.append(b)))(a)`, either.makeRight('abc')],
   [
     `{
       |>: f => a => :f(:a)
-      abc: a |> :atom.append(b) |> :atom.append(c)
+      ab: a |> :atom.append(b)
+      abc: :ab |> :atom.append(c)
     }.abc`,
     either.makeRight('abc'),
   ],

src/language/parsing.ts

@@ -1,5 +1,5 @@
 export type { Atom } from './parsing/atom.js'
-export type { Molecule } from './parsing/molecule.js'
+export type { Molecule } from './parsing/expression.js'
 export {
   canonicalize,
   type JsonValueForbiddingSymbolicKeys,

src/language/parsing/atom.ts

@@ -106,6 +106,6 @@ const quotedAtomParser = map(
   ([_1, contents, _2]) => contents,
 )
 
-export const atomParser: Parser<Atom> = optionallySurroundedByParentheses(
+export const atom: Parser<Atom> = optionallySurroundedByParentheses(
   oneOf([unquotedAtomParser, quotedAtomParser]),
 )

src/language/parsing/molecule.ts renamed to src/language/parsing/expression.ts

@@ -11,7 +11,7 @@ import {
 import type { Writable } from '../../utility-types.js'
 import { keyPathToMolecule, type KeyPath } from '../semantics.js'
 import {
-  atomParser,
+  atom,
   atomWithAdditionalQuotationRequirements,
   type Atom,
 } from './atom.js'
@@ -49,7 +49,7 @@ const optional = <Output>(
 ): Parser<Output | undefined> => oneOf([parser, nothing])
 
 const trailingIndexesAndArgumentsToExpression = (
-  root: Molecule,
+  root: Atom | Molecule,
   trailingIndexesAndArguments: readonly TrailingIndexOrArgument[],
 ) =>
   trailingIndexesAndArguments.reduce((expression, indexOrArgument) => {
@@ -69,73 +69,93 @@ const trailingIndexesAndArgumentsToExpression = (
     }
   }, root)
 
-const infixOperationToExpression = (
-  initialExpression: Atom | Molecule,
-  tokens: readonly [InfixToken, ...InfixToken[]],
-): Molecule => {
-  const [
-    [
-      [firstOperatorLookupKey, firstOperatorTrailingIndexesAndArguments],
-      firstArgument,
-    ],
-    ...additionalTokens
-  ] = tokens
-
-  const firstFunction = trailingIndexesAndArgumentsToExpression(
-    { 0: '@lookup', key: firstOperatorLookupKey },
-    firstOperatorTrailingIndexesAndArguments,
-  )
+type InfixOperator = readonly [Atom, readonly TrailingIndexOrArgument[]]
+type InfixOperand = Atom | Molecule
+type InfixToken = InfixOperator | InfixOperand
 
-  const initialApplication: Molecule = {
-    0: '@apply',
-    function: {
-      0: '@apply',
-      function: firstFunction,
-      argument: firstArgument,
-    },
-    argument: initialExpression,
-  }
+/**
+ * Infix operations should be of the following form:
+ * ```
+ * [InfixOperand, InfixOperator, InfixOperand, InfixOperator, …, InfixOperand]
+ * ```
+ * However this can't be directly modeled in TypeScript.
+ */
+type InfixOperation = readonly [InfixToken, ...InfixToken[]]
 
-  return additionalTokens.reduce(
-    (
-      expression,
-      [[operatorLookupKey, operatorTrailingIndexesAndArguments], nextArgument],
-    ) => {
-      const nextFunction = trailingIndexesAndArgumentsToExpression(
-        { 0: '@lookup', key: operatorLookupKey },
-        operatorTrailingIndexesAndArguments,
+const isOperand = (value: InfixToken | undefined): value is InfixOperand =>
+  !Array.isArray(value)
+const isOperator = (value: InfixToken | undefined): value is InfixOperator =>
+  Array.isArray(value)
+
+const appendToArray = <A>(b: A, init: readonly A[]): readonly [A, ...A[]] =>
+  // Unfortunately TypeScript can't reason through this on its own:
+  [...init, b] as readonly A[] as readonly [A, ...A[]]
+
+const infixTokensToExpression = (
+  operation: InfixOperation,
+): Molecule | Atom => {
+  const firstToken = operation[0]
+  if (operation.length === 1 && isOperand(firstToken)) {
+    return firstToken
+  } else {
+    const rightmostOperationRHS = operation[operation.length - 1]
+    if (rightmostOperationRHS === undefined) {
+      throw new Error('Infix operation was empty. This is a bug!')
+    }
+    if (!isOperand(rightmostOperationRHS)) {
+      throw new Error(
+        'Rightmost token in infix operation was not an operand. This is a bug!',
       )
-      return {
+    }
+    const rightmostOperator = operation[operation.length - 2]
+    if (!isOperator(rightmostOperator)) {
+      throw new Error(
+        'Could not find rightmost operator in infix operation. This is a bug!',
+      )
+    }
+
+    const rightmostOperationLHS = operation[operation.length - 3]
+    if (!isOperand(rightmostOperationLHS)) {
+      throw new Error(
+        'Missing left-hand side of infix operation. This is a bug!',
+      )
+    }
+
+    const rightmostFunction = trailingIndexesAndArgumentsToExpression(
+      { 0: '@lookup', key: rightmostOperator[0] },
+      rightmostOperator[1],
+    )
+
+    const reducedRightmostOperation: Molecule = {
+      0: '@apply',
+      function: {
         0: '@apply',
-        function: {
-          0: '@apply',
-          function: nextFunction,
-          argument: nextArgument,
-        },
-        argument: expression,
-      }
-    },
-    initialApplication,
-  )
+        function: rightmostFunction,
+        argument: rightmostOperationRHS,
+      },
+      argument: rightmostOperationLHS,
+    }
+
+    return infixTokensToExpression(
+      appendToArray(reducedRightmostOperation, operation.slice(0, -3)),
+    )
+  }
 }
 
 const atomRequiringDotQuotation = atomWithAdditionalQuotationRequirements(dot)
 
-const propertyKey: Parser<Atom> = atomParser
-const propertyValue: Parser<Molecule | Atom> = oneOf([
-  lazy(() => moleculeParser),
-  optionallySurroundedByParentheses(atomParser),
-])
-
 const namedProperty = map(
-  sequence([propertyKey, colon, optionalTrivia, propertyValue]),
+  sequence([atom, colon, optionalTrivia, lazy(() => expression)]),
   ([key, _colon, _trivia, value]) => [key, value] as const,
 )
 
 const propertyWithOptionalKey = optionallySurroundedByParentheses(
   oneOf([
     namedProperty,
-    map(propertyValue, value => [undefined, value] as const),
+    map(
+      lazy(() => expression),
+      value => [undefined, value] as const,
+    ),
   ]),
 )
 
@@ -144,7 +164,7 @@ const propertyDelimiter = oneOf([
   sequence([optional(triviaExceptNewlines), newline, optionalTrivia]),
 ])
 
-const argument = surroundedByParentheses(propertyValue)
+const argument = surroundedByParentheses(lazy(() => expression))
 
 const compactDottedKeyPathComponent = map(
   sequence([dot, atomRequiringDotQuotation]),
@@ -272,12 +292,10 @@ const compactExpression: Parser<Molecule | Atom> = oneOf([
   // {}
   lazy(() => precededByOpeningBrace),
   // 1
-  atomParser,
+  atom,
 ])
 
-const trailingInfixTokens: Parser<
-  readonly [InfixToken, ...(readonly InfixToken[])]
-> = oneOrMore(
+const trailingInfixTokens = oneOrMore(
   map(
     sequence([
       trivia,
@@ -301,9 +319,9 @@ const trailingInfixTokens: Parser<
   ),
 )
 
-type InfixToken = readonly [
-  readonly [Atom, readonly TrailingIndexOrArgument[]],
-  Molecule | Atom,
+type TrailingInfixToken = readonly [
+  operator: readonly [Atom, readonly TrailingIndexOrArgument[]],
+  operand: Molecule | Atom,
 ]
 type TrailingFunctionBodyOrInfixTokens =
   | {
@@ -313,11 +331,15 @@ type TrailingFunctionBodyOrInfixTokens =
     }
   | {
       readonly kind: 'infixTokens'
-      readonly tokens: readonly [InfixToken, ...(readonly InfixToken[])]
+      readonly tokens: readonly [
+        TrailingInfixToken,
+        ...(readonly TrailingInfixToken[]),
+      ]
     }
+
 const precededByAtomThenTrivia = map(
   sequence([
-    atomParser,
+    atom,
     oneOf([
       // a => :b
       // a => {}
@@ -331,11 +353,11 @@ const precededByAtomThenTrivia = map(
           trivia,
           zeroOrMore(
             map(
-              sequence([atomParser, trivia, arrow, trivia]),
+              sequence([atom, trivia, arrow, trivia]),
               ([parameter, _trivia1, _arrow, _trivia2]) => parameter,
             ),
           ),
-          propertyValue,
+          lazy(() => expression),
         ]),
         ([
           _trivia1,
@@ -381,10 +403,10 @@ const precededByAtomThenTrivia = map(
           initialFunction,
         )
       case 'infixTokens':
-        return infixOperationToExpression(
+        return infixTokensToExpression([
           initialAtom,
-          trailingFunctionBodyOrInfixTokens.tokens,
-        )
+          ...trailingFunctionBodyOrInfixTokens.tokens.flat(),
+        ])
     }
   },
 )
@@ -425,9 +447,10 @@ const precededByColonThenAtom = map(
     if (firstToken === undefined) {
       return initialExpression
     } else {
-      return infixOperationToExpression(initialExpression, [
-        firstToken,
-        ...additionalTokens,
+      return infixTokensToExpression([
+        initialExpression,
+        ...firstToken,
+        ...additionalTokens.flat(),
       ])
     }
   },
@@ -444,15 +467,18 @@ const precededByColonThenAtom = map(
 const precededByOpeningParenthesis = oneOf([
   map(
     sequence([
-      surroundedByParentheses(lazy(() => moleculeParser)),
+      surroundedByParentheses(lazy(() => expression)),
       trailingInfixTokens,
     ]),
     ([initialExpression, trailingInfixTokens]) =>
-      infixOperationToExpression(initialExpression, trailingInfixTokens),
+      infixTokensToExpression([
+        initialExpression,
+        ...trailingInfixTokens.flat(),
+      ]),
   ),
   map(
     sequence([
-      surroundedByParentheses(lazy(() => moleculeParser)),
+      surroundedByParentheses(lazy(() => expression)),
       trailingIndexesAndArguments,
     ]),
     ([expression, trailingIndexesAndArguments]) =>
@@ -476,9 +502,10 @@ const precededByOpeningBrace = map(
     ),
 )
 
-export const moleculeParser: Parser<Molecule> = oneOf([
+export const expression: Parser<Atom | Molecule> = oneOf([
   precededByOpeningParenthesis,
   precededByOpeningBrace,
   precededByColonThenAtom,
   precededByAtomThenTrivia,
+  atom,
 ])