Adopt more either utilities

Author: mkantor

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

@@ -89,12 +89,8 @@ const apply = (
     ),
   )
 
-  if (either.isLeft(result)) {
-    return either.makeLeft({
-      kind: 'panic',
-      message: result.value.message,
-    })
-  } else {
-    return result
-  }
+  return either.mapLeft(result, error => ({
+    kind: 'panic',
+    message: error.message,
+  }))
 }

src/language/runtime/keywords.ts

@@ -160,16 +160,12 @@ export const keywordHandlers: KeywordHandlers = {
           const result = runtimeFunction(
             runtimeContext(runtimeFunction.parameterName),
           )
-          if (either.isLeft(result)) {
-            // The runtime function panicked or had an unavailable dependency (which results in a panic
-            // anyway in this context).
-            return either.makeLeft({
-              kind: 'panic',
-              message: result.value.message,
-            })
-          } else {
-            return result
-          }
+          return either.mapLeft(result, error => ({
+            // The runtime function panicked or had an unavailable dependency (which results in a
+            // panic anyway in this context).
+            kind: 'panic',
+            message: error.message,
+          }))
         }
       },
     ),

src/language/semantics/stdlib/atom.ts

@@ -61,19 +61,14 @@ export const atom = {
           },
           serializeOnceAppliedFunction(['atom', 'prepend'], atomToPrepend),
           option.none,
-          atomToPrependTo => {
-            if (
-              typeof atomToPrepend !== 'string' ||
-              typeof atomToPrependTo !== 'string'
-            ) {
-              return either.makeLeft({
-                kind: 'panic',
-                message: 'prepend received a non-atom argument',
-              })
-            } else {
-              return either.makeRight(atomToPrepend + atomToPrependTo)
-            }
-          },
+          atomToPrependTo =>
+            typeof atomToPrepend !== 'string' ||
+            typeof atomToPrependTo !== 'string'
+              ? either.makeLeft({
+                  kind: 'panic',
+                  message: 'prepend received a non-atom argument',
+                })
+              : either.makeRight(atomToPrepend + atomToPrependTo),
         ),
       ),
   ),

src/language/unparsing/plz-utilities.ts

@@ -62,11 +62,9 @@ export const moleculeUnparser =
             value,
             unparseAtomOrMolecule,
           )
-          if (either.isLeft(result)) {
-            return unparseSugarFreeMolecule(value, unparseAtomOrMolecule)
-          } else {
-            return result
-          }
+          return either.flatMapLeft(result, _ =>
+            unparseSugarFreeMolecule(value, unparseAtomOrMolecule),
+          )
         } else {
           return unparseSugarFreeMolecule(value, unparseAtomOrMolecule)
         }
@@ -156,34 +154,30 @@ const unparseSugaredApply = (
   unparseAtomOrMolecule: UnparseAtomOrMolecule,
 ) => {
   const { closeParenthesis, openParenthesis } = punctuation(kleur)
-  const functionUnparseResult = either.map(
-    either.flatMap(
-      serializeIfNeeded(expression[1].function),
-      unparseAtomOrMolecule,
+  return either.flatMap(
+    either.map(
+      either.flatMap(
+        serializeIfNeeded(expression[1].function),
+        unparseAtomOrMolecule,
+      ),
+      unparsedFunction =>
+        either.isRight(readFunctionExpression(expression[1].function))
+          ? // Immediately-applied function expressions need parentheses.
+            openParenthesis.concat(unparsedFunction).concat(closeParenthesis)
+          : unparsedFunction,
     ),
     unparsedFunction =>
-      either.isRight(readFunctionExpression(expression[1].function))
-        ? // Immediately-applied function expressions need parentheses.
-          openParenthesis.concat(unparsedFunction).concat(closeParenthesis)
-        : unparsedFunction,
-  )
-  if (either.isLeft(functionUnparseResult)) {
-    return functionUnparseResult
-  }
-
-  const argumentUnparseResult = either.flatMap(
-    serializeIfNeeded(expression[1].argument),
-    unparseAtomOrMolecule,
-  )
-  if (either.isLeft(argumentUnparseResult)) {
-    return argumentUnparseResult
-  }
-
-  return either.makeRight(
-    functionUnparseResult.value
-      .concat(openParenthesis)
-      .concat(argumentUnparseResult.value)
-      .concat(closeParenthesis),
+      either.map(
+        either.flatMap(
+          serializeIfNeeded(expression[1].argument),
+          unparseAtomOrMolecule,
+        ),
+        unparsedArgument =>
+          unparsedFunction
+            .concat(openParenthesis)
+            .concat(unparsedArgument)
+            .concat(closeParenthesis),
+      ),
   )
 }
 
@@ -209,12 +203,10 @@ const unparseSugaredIndex = (
     serializeIfNeeded(expression[1].object),
     unparseAtomOrMolecule,
   )
-  if (either.isLeft(objectUnparseResult)) {
-    return objectUnparseResult
-  } else {
+  return either.flatMap(objectUnparseResult, unparsedObject => {
     if (typeof expression[1].query !== 'object') {
       // TODO: It would be nice if this were provably impossible.
-      return either.makeLeft({
+      return either.makeLeft<UnserializableValueError>({
         kind: 'unserializableValue',
         message: 'Invalid index expression',
       })
@@ -248,13 +240,13 @@ const unparseSugaredIndex = (
       } else {
         const { dot } = punctuation(kleur)
         return either.makeRight(
-          objectUnparseResult.value
+          unparsedObject
             .concat(dot)
             .concat(keyPath.map(quoteKeyPathComponentIfNecessary).join(dot)),
         )
       }
     }
-  }
+  })
 }
 
 const unparseSugaredLookup = (