September 2017 Update

Task/Comma-quibbling/JavaScript/comma-quibbling-2.js

@@ -0,0 +1,93 @@
+(() => {
+    'use strict';
+
+    // COMMA QUIBBLING -------------------------------------------------------
+
+    // quibble :: [String] -> String
+    const quibble = xs =>
+        (xs.length > 1) ? (
+            intercalate(
+                " and ",
+                ap(
+                    [compose([intercalate(", "), reverse, tail]), head], //
+                    [reverse(xs)]
+                )
+            )
+        ) : concat(xs);
+
+
+    // GENERIC FUNCTIONS -----------------------------------------------------
+
+    // A list of functions applied to a list of arguments
+    // <*> :: [(a -> b)] -> [a] -> [b]
+    const ap = (fs, xs) => //
+        [].concat.apply([], fs.map(f => //
+            [].concat.apply([], xs.map(x => [f(x)]))));
+
+    // curry :: Function -> Function
+    const curry = (f, ...args) => {
+        const go = xs => xs.length >= f.length ? (f.apply(null, xs)) :
+            function () {
+                return go(xs.concat([].slice.apply(arguments)));
+            };
+        return go([].slice.call(args, 1));
+    };
+
+    // intercalate :: String -> [a] -> String
+    const intercalate = curry((s, xs) => xs.join(s));
+
+    // concat :: [[a]] -> [a] | [String] -> String
+    const concat = xs => {
+        if (xs.length > 0) {
+            const unit = typeof xs[0] === 'string' ? '' : [];
+            return unit.concat.apply(unit, xs);
+        } else return [];
+    };
+
+    // compose :: [(a -> a)] -> (a -> a)
+    const compose = fs => x => fs.reduceRight((a, f) => f(a), x);
+
+    // map :: (a -> b) -> [a] -> [b]
+    const map = curry((f, xs) => xs.map(f));
+
+    // reverse :: [a] -> [a]
+    const reverse = xs =>
+        typeof xs === 'string' ? (
+            xs.split('')
+            .reverse()
+            .join('')
+        ) : xs.slice(0)
+        .reverse();
+
+    // head :: [a] -> a
+    const head = xs => xs.length ? xs[0] : undefined;
+
+    // tail :: [a] -> [a]
+    const tail = xs => xs.length ? xs.slice(1) : undefined;
+
+    // (++) :: [a] -> [a] -> [a]
+    const append = (xs, ys) => xs.concat(ys);
+
+    // words :: String -> [String]
+    const words = s => s.split(/\s+/);
+
+    // unlines :: [String] -> String
+    const unlines = xs => xs.join('\n');
+
+
+    // TEST ------------------------------------------------------------------
+    return unlines(
+        map(
+            compose([x => '{' + x + '}', quibble]),
+            append([
+                [],
+                ["ABC"],
+                ["ABC", "DEF"],
+                ["ABC", "DEF", "G", "H"]
+            ], map(
+                words, [
+                    "One two three four", "Me myself I", "Jack Jill", "Loner"
+                ]
+            ))
+        ));
+})();