Make infix expressions left-associative (again)

After trying out both I think I prefer this and imagine it's what most
people will expect. I've preserved my flip-flopping in version control
history for posterity.

Author: mkantor

README.md

@@ -156,7 +156,7 @@ 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 } }`
 }
 ```
 
@@ -174,10 +174,8 @@ in the standard library are the functions`|>` (pipe) and `>>` (flow):
 }
 ```
 
-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.
+All binary operations are currently left-associative and there is no operator
+precedence. Use of parentheses is encouraged.
 
 #### Keywords
 

src/end-to-end.test.ts

@@ -168,12 +168,7 @@ 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('-4')],
   [`1 - (2 - 3)`, either.makeRight('2')],
   [`(1 - 2) - 3`, either.makeRight('-4')],
   [':flow(:atom.append(b))(:atom.append(a))(z)', either.makeRight('zab')],
@@ -322,7 +317,7 @@ 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')],
-  [`a atom.append c atom.prepend b`, either.makeRight('abc')],
+  [`b atom.append c atom.prepend a`, either.makeRight('abc')],
   [`(b atom.append c) atom.prepend a`, either.makeRight('abc')],
   [`a atom.append (c atom.prepend b)`, either.makeRight('abc')],
   [
@@ -345,7 +340,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
       (
         PATH
           |> :context.environment.lookup
-          >> :match({
+          |> :match({
             none: _ => "$PATH not set"
             some: :atom.prepend("PATH=")
           })
@@ -385,8 +380,8 @@ 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')],
   [
     `{
@@ -403,4 +398,29 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     }.abc`,
     either.makeRight('abc'),
   ],
+  [
+    `{
+      nested_option: {
+        tag: some,
+        value: {
+          tag: some,
+          value: {
+            tag: some,
+            value: "it works!"
+          }
+        }
+      }
+      output: :nested_option match {
+        none: unreachable
+        some: :identity
+      } match {
+        none: unreachable
+        some: :identity
+      } match {
+        none: unreachable
+        some: :identity
+      }
+    }.output`,
+    either.makeRight('it works!'),
+  ],
 ])

src/language/parsing/expression.ts

@@ -87,58 +87,56 @@ const isOperand = (value: InfixToken | undefined): value is InfixOperand =>
 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) {
+    const leftmostOperationLHS = operation[0]
+    if (leftmostOperationLHS === undefined) {
       throw new Error('Infix operation was empty. This is a bug!')
     }
-    if (!isOperand(rightmostOperationRHS)) {
+    if (!isOperand(leftmostOperationLHS)) {
       throw new Error(
-        'Rightmost token in infix operation was not an operand. This is a bug!',
+        'Leftmost token in infix operation was not an operand. This is a bug!',
       )
     }
-    const rightmostOperator = operation[operation.length - 2]
-    if (!isOperator(rightmostOperator)) {
+
+    const leftmostOperator = operation[1]
+    if (!isOperator(leftmostOperator)) {
       throw new Error(
-        'Could not find rightmost operator in infix operation. This is a bug!',
+        'Could not find leftmost operator in infix operation. This is a bug!',
       )
     }
 
-    const rightmostOperationLHS = operation[operation.length - 3]
-    if (!isOperand(rightmostOperationLHS)) {
+    const leftmostOperationRHS = operation[2]
+    if (!isOperand(leftmostOperationRHS)) {
       throw new Error(
-        'Missing left-hand side of infix operation. This is a bug!',
+        'Missing right-hand side of infix operation. This is a bug!',
       )
     }
 
-    const rightmostFunction = trailingIndexesAndArgumentsToExpression(
-      { 0: '@lookup', key: rightmostOperator[0] },
-      rightmostOperator[1],
+    const leftmostFunction = trailingIndexesAndArgumentsToExpression(
+      { 0: '@lookup', key: leftmostOperator[0] },
+      leftmostOperator[1],
     )
 
-    const reducedRightmostOperation: Molecule = {
+    const reducedLeftmostOperation: Molecule = {
       0: '@apply',
       function: {
         0: '@apply',
-        function: rightmostFunction,
-        argument: rightmostOperationRHS,
+        function: leftmostFunction,
+        argument: leftmostOperationRHS,
       },
-      argument: rightmostOperationLHS,
+      argument: leftmostOperationLHS,
     }
 
-    return infixTokensToExpression(
-      appendToArray(reducedRightmostOperation, operation.slice(0, -3)),
-    )
+    return infixTokensToExpression([
+      reducedLeftmostOperation,
+      ...operation.slice(3),
+    ])
   }
 }