September 2017 Update

Task/Permutations/JavaScript/permutations-4.js

@@ -1,39 +1,35 @@
 (function () {
+    'use strict';
 
     // permutations :: [a] -> [[a]]
-    function permutations(xs) {
-        return xs.length ? (concatMap(
-            function (x) {
-                return concatMap(
-                    function (ys) {
-                        return ([[x].concat(ys)]);
-                    }, permutations(delete1(x, xs)))
-            }, xs)) : [[]]
-    }
+    var permutations = function (xs) {
+        return xs.length ? concatMap(function (x) {
+            return concatMap(function (ys) {
+                return [[x].concat(ys)];
+            }, permutations(delete_(x, xs)));
+        }, xs) : [[]];
+    };
 
-
-    // GENERIC LIBRARY FUNCTIONS
+    // GENERIC FUNCTIONS
 
     // concatMap :: (a -> [b]) -> [a] -> [b]
-    function concatMap(f, xs) {
+    var concatMap = function (f, xs) {
         return [].concat.apply([], xs.map(f));
-    }
+    };
 
-    // delete first instance of a in [a]
-    // delete1 :: a -> [a] -> [a]
-    function delete1(x, xs) {
+    // delete :: Eq a => a -> [a] -> [a]
+    var delete_ = function (x, xs) {
         return deleteBy(function (a, b) {
             return a === b;
         }, x, xs);
-    }
+    };
 
     // deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
-    function deleteBy(fnEq, x, xs) {
-        return xs.length ? fnEq(x, xs[0]) ? xs.slice(1) : [xs[0]]
-            .concat(deleteBy(fnEq, x, xs.slice(1))) : [];
-    }
-
-
-    return permutations(['Aardvarks', 'eat', 'ants'])
+    var deleteBy = function (f, x, xs) {
+        return xs.length > 0 ? f(x, xs[0]) ? xs.slice(1) :
+        [xs[0]].concat(deleteBy(f, x, xs.slice(1))) : [];
+    };
 
+    // TEST
+    return permutations(['Aardvarks', 'eat', 'ants']);
 })();

Task/Permutations/JavaScript/permutations-6.js

@@ -1,19 +1,38 @@
-(function (lst) {
+(() => {
     'use strict';
 
-    const permutations = (xs) => xs.length ? (
-            flatMap((x) => flatMap((xs) => [[x].concat(xs)],
-                permutations(del(x, xs))), xs)
-        ) : [[]],
+    // permutations :: [a] -> [[a]]
+    const permutations = xs =>
+        xs.length ? concatMap(x => concatMap(ys => [
+                [x].concat(ys)
+            ],
+            permutations(delete_(x, xs))), xs) : [
+            []
+        ];
 
-        flatMap = (f, xs) => [].concat.apply([], xs.map(f)),
+    // GENERIC FUNCTIONS
 
-        del = (x, xs) => xs.length ? x === xs[0] ? (
-            xs.slice(1)
-        ) : [xs[0]].concat(del(x, xs.slice(1))
+    // concatMap :: (a -> [b]) -> [a] -> [b]
+    const concatMap = (f, xs) => [].concat.apply([], xs.map(f));
+    //
+    // // delete :: Eq a => a -> [a] -> [a]
+    // const delete_ = (x, xs) =>
+    //     deleteBy((a, b) => a === b, x, xs);
+
+    // delete_ :: Eq a => a -> [a] -> [a]
+    const delete_ = (x, xs) =>
+        xs.length > 0 ? (
+            (x === xs[0]) ? (
+                xs.slice(1)
+            ) : [xs[0]].concat(delete_(x, xs.slice(1)))
         ) : [];
 
+    // range :: Int -> Int -> [Int]
+    const range = (m, n) =>
+        Array.from({
+            length: Math.floor(n - m) + 1
+        }, (_, i) => m + i);
 
-    return permutations(lst);
-
-})(["Aardvarks", "eat", "ants"]);
+    // TEST
+    return permutations(['Aardvarks', 'eat', 'ants']);
+})();