Rename atom.concatenate to atom.append, add atom.prepend

Author: mkantor

src/end-to-end.test.ts

@@ -75,11 +75,8 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     either.makeRight('output'),
   ],
   [':match({ a: A })({ tag: a, value: {} })', either.makeRight('A')],
-  [':{atom concatenate}(a)(b)', either.makeRight('ba')],
-  [
-    ':flow({ :atom.concatenate(a) :atom.concatenate(b) })(z)',
-    either.makeRight('zab'),
-  ],
+  [':{atom prepend}(a)(b)', either.makeRight('ab')],
+  [':flow({ :atom.append(a) :atom.append(b) })(z)', either.makeRight('zab')],
   [
     `{
         // foo: bar

src/language/semantics/prelude.ts

@@ -496,32 +496,72 @@ export const prelude: ObjectNode = makeObjectNode({
   }),
 
   atom: makeObjectNode({
-    concatenate: preludeFunction(
-      ['atom', 'concatenate'],
+    append: preludeFunction(
+      ['atom', 'append'],
       {
         parameter: types.atom,
         return: makeFunctionType('', {
           parameter: types.atom,
           return: types.atom,
         }),
       },
-      string2 =>
+      atomToAppend =>
         either.makeRight(
           makeFunctionNode(
             {
               parameter: types.atom,
               return: types.atom,
             },
-            serializePartiallyAppliedFunction(['atom', 'concatenate'], string2),
+            serializePartiallyAppliedFunction(['atom', 'append'], atomToAppend),
             option.none,
-            string1 => {
-              if (typeof string1 !== 'string' || typeof string1 !== 'string') {
+            atomToAppendTo => {
+              if (
+                typeof atomToAppend !== 'string' ||
+                typeof atomToAppendTo !== 'string'
+              ) {
+                return either.makeLeft({
+                  kind: 'panic',
+                  message: 'append received a non-atom argument',
+                })
+              } else {
+                return either.makeRight(atomToAppendTo + atomToAppend)
+              }
+            },
+          ),
+        ),
+    ),
+    prepend: preludeFunction(
+      ['atom', 'prepend'],
+      {
+        parameter: types.atom,
+        return: makeFunctionType('', {
+          parameter: types.atom,
+          return: types.atom,
+        }),
+      },
+      atomToPrepend =>
+        either.makeRight(
+          makeFunctionNode(
+            {
+              parameter: types.atom,
+              return: types.atom,
+            },
+            serializePartiallyAppliedFunction(
+              ['atom', 'prepend'],
+              atomToPrepend,
+            ),
+            option.none,
+            atomToPrependTo => {
+              if (
+                typeof atomToPrepend !== 'string' ||
+                typeof atomToPrependTo !== 'string'
+              ) {
                 return either.makeLeft({
                   kind: 'panic',
-                  message: 'concatenate received a non-atom argument',
+                  message: 'prepend received a non-atom argument',
                 })
               } else {
-                return either.makeRight(string1 + string2)
+                return either.makeRight(atomToPrepend + atomToPrependTo)
               }
             },
           ),