Initial data commit

Task/List-comprehensions/JavaScript/list-comprehensions-1.js

@@ -0,0 +1,32 @@
+// USING A LIST MONAD DIRECTLY, WITHOUT SPECIAL SYNTAX FOR LIST COMPREHENSIONS
+
+(function (n) {
+
+    return mb(r(1,     n), function (x) {  // x <- [1..n]
+    return mb(r(1 + x, n), function (y) {  // y <- [1+x..n]
+    return mb(r(1 + y, n), function (z) {  // z <- [1+y..n]
+
+       return x * x + y * y === z * z ? [[x, y, z]] : [];
+
+    })})});
+
+
+    // LIBRARY FUNCTIONS
+
+    // Monadic bind for lists
+    function mb(xs, f) {
+        return [].concat.apply([], xs.map(f));
+    }
+
+    // Monadic return for lists is simply lambda x -> [x]
+    // as in [[x, y, z]] : [] above
+
+    // Integer range [m..n]
+    function r(m, n) {
+        return Array.apply(null, Array(n - m + 1))
+            .map(function (n, x) {
+                return m + x;
+            });
+    }
+
+})(100);

Task/List-comprehensions/JavaScript/list-comprehensions-2.js

@@ -0,0 +1,17 @@
+function range(begin, end) {
+    for (let i = begin; i < end; ++i)
+        yield i;
+}
+
+function triples(n) {
+    return [
+        [x, y, z]
+        for each(x in range(1, n + 1))
+        for each(y in range(x, n + 1))
+        for each(z in range(y, n + 1))
+        if (x * x + y * y == z * z)
+    ]
+}
+
+for each(var triple in triples(20))
+print(triple);

Task/List-comprehensions/JavaScript/list-comprehensions-3.js

@@ -0,0 +1,31 @@
+(n => {
+    'use strict';
+
+    // GENERIC FUNCTIONS ------------------------------------------------------
+
+    // concatMap :: (a -> [b]) -> [a] -> [b]
+    const concatMap = (f, xs) => [].concat.apply([], xs.map(f));
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = (m, n) =>
+        Array.from({
+            length: Math.floor(n - m) + 1
+        }, (_, i) => m + i);
+
+
+    // EXAMPLE ----------------------------------------------------------------
+
+    // [(x, y, z) | x <- [1..n], y <- [x..n], z <- [y..n], x ^ 2 + y ^ 2 == z ^ 2]
+
+    return concatMap(x =>
+           concatMap(y =>
+           concatMap(z =>
+
+                x * x + y * y === z * z ? [
+                    [x, y, z]
+                ] : [],
+
+           enumFromTo(y, n)),
+           enumFromTo(x, n)),
+           enumFromTo(1, n));
+})(20);

Task/List-comprehensions/JavaScript/list-comprehensions-4.js

@@ -0,0 +1,41 @@
+(n => {
+    'use strict';
+
+    // GENERIC FUNCTIONS ------------------------------------------------------
+
+    // bind (>>=) :: Monad m => m a -> (a -> m b) -> m b
+    const bind = (m, mf) =>
+        Array.isArray(m) ? (
+            bindList(m, mf)
+        ) : bindMay(m, mf);
+
+    // bindList (>>=) :: [a] -> (a -> [b]) -> [b]
+    const bindList = (xs, mf) => [].concat.apply([], xs.map(mf));
+
+    // enumFromTo :: Enum a => a -> a -> [a]
+    const enumFromTo = (m, n) =>
+        (typeof m !== 'number' ? (
+            enumFromToChar
+        ) : enumFromToInt)
+        .apply(null, [m, n]);
+
+    // enumFromToInt :: Int -> Int -> [Int]
+    const enumFromToInt = (m, n) =>
+        Array.from({
+            length: Math.floor(n - m) + 1
+        }, (_, i) => m + i);
+
+
+    // EXAMPLE ----------------------------------------------------------------
+
+    // [(x, y, z) | x <- [1..n], y <- [x..n], z <- [y..n], x ^ 2 + y ^ 2 == z ^ 2]
+
+    return   bind(enumFromTo(1, n),
+        x => bind(enumFromTo(x, n),
+        y => bind(enumFromTo(y, n),
+        z => x * x + y * y === z * z ? [
+                    [x, y, z]
+            ] : []
+        )));
+
+})(20);

Task/List-comprehensions/JavaScript/list-comprehensions-5.js

@@ -0,0 +1 @@
+[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]