Merge pull request #53 from mkantor/miscellanea

Miscellaneous minor improvements

Author: mkantor

src/language/cli/input.ts

@@ -18,6 +18,10 @@ export const handleInput = async <Result>(
       'input-format': { type: 'string' },
     },
   })
+
+  // Only JSON is supported currently. `--input-format` isn't really necessary
+  // right now, but requiring it ensures forwards-compatibility of scripts when
+  // other formats are added.
   if (args.values['input-format'] === undefined) {
     throw new Error('Missing required option: --input-format')
   } else if (args.values['input-format'] !== 'json') {

src/language/runtime/evaluator.test.ts

@@ -59,7 +59,9 @@ testCases(evaluate, input => `evaluating \`${JSON.stringify(input)}\``)(
         ],
       ],
       output => {
-        assert(!either.isLeft(output))
+        if (either.isLeft(output)) {
+          assert.fail(output.value.message)
+        }
         assert(typeof output.value === 'object')
         assert(output.value['tag'] === 'some')
         assert(typeof output.value['value'] === 'string')

src/language/semantics/prelude.ts

@@ -63,7 +63,7 @@ const keyPathToLookupExpression = (keyPath: NonEmptyKeyPath) => {
   }
 }
 
-const serializePartiallyAppliedFunction =
+const serializeOnceAppliedFunction =
   (keyPath: NonEmptyKeyPath, argument: SemanticGraph) => () =>
     either.makeRight(
       makeApplyExpression({
@@ -108,7 +108,7 @@ export const prelude: ObjectNode = makeObjectNode({
             parameter: types.functionType,
             return: types.something,
           },
-          serializePartiallyAppliedFunction(['apply'], argument),
+          serializeOnceAppliedFunction(['apply'], argument),
           option.none,
           functionToApply => {
             if (!isFunctionNode(functionToApply)) {
@@ -175,7 +175,7 @@ export const prelude: ObjectNode = makeObjectNode({
                 parameter: function0.signature.parameter,
                 return: function1.signature.parameter,
               },
-              serializePartiallyAppliedFunction(
+              serializeOnceAppliedFunction(
                 ['flow'],
                 makeObjectNode({ 0: function0, 1: function1 }),
               ),
@@ -205,7 +205,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.integer,
               return: types.integer,
             },
-            serializePartiallyAppliedFunction(['integer', 'add'], number2),
+            serializeOnceAppliedFunction(['integer', 'add'], number2),
             option.none,
             number1 => {
               if (
@@ -262,10 +262,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.integer,
               return: types.boolean,
             },
-            serializePartiallyAppliedFunction(
-              ['integer', 'less_than'],
-              number2,
-            ),
+            serializeOnceAppliedFunction(['integer', 'less_than'], number2),
             option.none,
             number1 => {
               if (
@@ -304,7 +301,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.integer,
               return: types.integer,
             },
-            serializePartiallyAppliedFunction(['integer', 'subtract'], number2),
+            serializeOnceAppliedFunction(['integer', 'subtract'], number2),
             option.none,
             number1 => {
               if (
@@ -384,7 +381,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.something,
               return: types.something,
             },
-            serializePartiallyAppliedFunction(['match'], cases),
+            serializeOnceAppliedFunction(['match'], cases),
             option.none,
             argument => {
               if (!nodeIsTagged(argument)) {
@@ -432,10 +429,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.naturalNumber,
               return: types.naturalNumber,
             },
-            serializePartiallyAppliedFunction(
-              ['natural_number', 'add'],
-              number2,
-            ),
+            serializeOnceAppliedFunction(['natural_number', 'add'], number2),
             option.none,
             number1 => {
               if (
@@ -509,7 +503,7 @@ export const prelude: ObjectNode = makeObjectNode({
                 parameter: types.something,
                 return: types.something,
               },
-              serializePartiallyAppliedFunction(['object', 'lookup'], key),
+              serializeOnceAppliedFunction(['object', 'lookup'], key),
               option.none,
               argument => {
                 if (!isObjectNode(argument)) {
@@ -560,7 +554,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.atom,
               return: types.atom,
             },
-            serializePartiallyAppliedFunction(['atom', 'append'], atomToAppend),
+            serializeOnceAppliedFunction(['atom', 'append'], atomToAppend),
             option.none,
             atomToAppendTo => {
               if (
@@ -594,10 +588,7 @@ export const prelude: ObjectNode = makeObjectNode({
               parameter: types.atom,
               return: types.atom,
             },
-            serializePartiallyAppliedFunction(
-              ['atom', 'prepend'],
-              atomToPrepend,
-            ),
+            serializeOnceAppliedFunction(['atom', 'prepend'], atomToPrepend),
             option.none,
             atomToPrependTo => {
               if (

src/language/unparsing/plz-utilities.ts

@@ -195,40 +195,50 @@ const unparseSugaredIndex = (
   )
   if (either.isLeft(objectUnparseResult)) {
     return objectUnparseResult
-  }
+  } else {
+    if (typeof expression.query !== 'object') {
+      // TODO: It would be nice if this were provably impossible.
+      return either.makeLeft({
+        kind: 'unserializableValue',
+        message: 'Invalid index expression',
+      })
+    } else {
+      const keyPath = Object.entries(expression.query).reduce(
+        (accumulator: KeyPath | 'invalid', [key, value]) => {
+          if (accumulator === 'invalid') {
+            return accumulator
+          } else {
+            if (
+              key === String(accumulator.length) &&
+              typeof value === 'string'
+            ) {
+              return [...accumulator, value]
+            } else {
+              return 'invalid'
+            }
+          }
+        },
+        [],
+      )
 
-  const keyPath = Object.entries(expression.query).reduce(
-    (accumulator: KeyPath | 'invalid', [key, value]) => {
-      if (accumulator === 'invalid') {
-        return accumulator
+      if (
+        keyPath === 'invalid' ||
+        Object.keys(expression.query).length !== keyPath.length
+      ) {
+        return either.makeLeft({
+          kind: 'unserializableValue',
+          message: 'invalid key path',
+        })
       } else {
-        if (key === String(accumulator.length) && typeof value === 'string') {
-          return [...accumulator, value]
-        } else {
-          return 'invalid'
-        }
+        const { dot } = punctuation(kleur)
+        return either.makeRight(
+          objectUnparseResult.value
+            .concat(dot)
+            .concat(keyPath.map(quoteKeyPathComponentIfNecessary).join(dot)),
+        )
       }
-    },
-    [],
-  )
-
-  if (
-    keyPath === 'invalid' ||
-    Object.keys(expression.query).length !== keyPath.length
-  ) {
-    return either.makeLeft({
-      kind: 'unserializableValue',
-      message: 'invalid key path',
-    })
+    }
   }
-
-  const { dot } = punctuation(kleur)
-
-  return either.makeRight(
-    objectUnparseResult.value
-      .concat(dot)
-      .concat(keyPath.map(quoteKeyPathComponentIfNecessary).join(dot)),
-  )
 }
 
 const unparseSugaredLookup = (