Initial data commit

Task/Balanced-brackets/JavaScript/balanced-brackets-3.js

@@ -0,0 +1,105 @@
+(() => {
+    'use strict';
+
+    // ---------------- BALANCED BRACKETS ----------------
+
+    // firstUnbalancedBracket :: String -> String -> Maybe Int
+    const firstUnbalancedBracket = brackets =>
+        haystack => {
+            const [openBracket, closeBracket] = [...brackets];
+            const go = (xs, iDepth, iCharPosn) =>
+                // iDepth: initial nesting depth (0 = closed)
+                // iCharPosn: starting character position
+                0 < xs.length ? (() => {
+                    const
+                        h = xs[0],
+                        tail = xs.slice(1),
+                        iNext = iDepth + (
+                            brackets.includes(h) ? (
+                                openBracket === h ? (
+                                    1
+                                ) : -1
+                            ) : 0
+                        );
+                    return 0 > iNext ? (
+                        Just(iCharPosn) // Unmatched closing bracket.
+                    ) : 0 < tail.length ? go(
+                        tail, iNext, 1 + iCharPosn
+                    ) : 0 !== iNext ? (
+                        Just(iCharPosn)
+                    ) : Nothing();
+                })() : 0 !== iDepth ? (
+                    Just(iCharPosn)
+                ) : Nothing();
+            return go([...haystack], 0, 0);
+        };
+
+
+    // ---------------------- TEST -----------------------
+    // main :: IO ()
+    const main = () => {
+        const
+            intPairs = 6,
+            strPad = ' '.repeat(4 + (2 * intPairs));
+        console.log(
+            enumFromTo(0)(intPairs)
+            .map(pairCount => {
+                const
+                    stringLength = 2 * pairCount,
+                    strSample = randomBrackets(stringLength);
+                return "'" + strSample + "'" +
+                    strPad.slice(2 + stringLength) + maybe('OK')(
+                        iUnMatched => 'problem\n' +
+                        ' '.repeat(1 + iUnMatched) + '^'
+                    )(
+                        firstUnbalancedBracket('[]')(strSample)
+                    );
+            }).join('\n')
+        );
+    };
+
+
+    // Int -> String
+    const randomBrackets = n =>
+        enumFromTo(1)(n)
+        .map(() => Math.random() < 0.5 ? (
+            '['
+        ) : ']').join('');
+
+
+    // --------------------- GENERIC ---------------------
+
+    // Just :: a -> Maybe a
+    const Just = x => ({
+        type: 'Maybe',
+        Nothing: false,
+        Just: x
+    });
+
+
+    // Nothing :: Maybe a
+    const Nothing = () => ({
+        type: 'Maybe',
+        Nothing: true,
+    });
+
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = m =>
+        n => !isNaN(m) ? (
+            Array.from({
+                length: 1 + n - m
+            }, (_, i) => m + i)
+        ) : enumFromTo_(m)(n);
+
+
+    // maybe :: b -> (a -> b) -> Maybe a -> b
+    const maybe = v =>
+        // Default value (v) if m is Nothing, or f(m.Just)
+        f => m => m.Nothing ? (
+            v
+        ) : f(m.Just);
+
+    // ---
+    return main();
+})();