yukigo-haskell-parser 0.1.0 → 0.1.2

package/dist/parser/lexer.js

@@ -1,75 +1,284 @@
 import moo from "moo";
 import { keywords } from "../utils/types.js";
-import { makeLexer } from "moo-ignore";
-import IndentationLexer from "moo-indentation-lexer";
 export const HaskellLexerConfig = {
-    NL: { match: /\r?\n/, lineBreaks: true },
-    anonymousVariable: "_",
-    WS: / |\t/,
-    comment: /--.*?$|{-[\s\S]*?-}/,
+    comment: { match: /--.*?$|{-[\s\S]*?-}/, lineBreaks: true },
     number: /0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d*\.\d+|\d+)(?:[eE][+-]?\d+)?/,
     char: /'(?:\\['\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^'\\\n\r])?'/,
-    string: /"(?:\\["\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^"\\\n\r])*"/,
-    //template: /`(?:\\[\s\S]|[^\\`])*`/,
-    backtick: "`",
+    string: { match: /"(?:\\[\s\S]|[^"\\])*"/, lineBreaks: true },
     lparen: "(",
     rparen: ")",
     lbracket: "{",
     rbracket: "}",
     lsquare: "[",
     rsquare: "]",
-    rangeOperator: "..",
     semicolon: ";",
     typeArrow: "->",
     leftArrow: "<-",
     typeEquals: "::",
-    question: "?",
-    arrow: "=>",
-    bool: {
-        match: ["True", "False"],
+    fatArrow: "=>",
+    op: {
+        match: /,|>>=|>>|\\\\|\\|\.\.|\.|\+\+|\+|\-|\*\*|\*|===|!==|==|\/=|<=|>=|<|>|&&|\/|\|\||\$!|\$|\^\^|\^|#|@|~|!!|!|%|\?|:|&|`/,
+        lineBreaks: false,
     },
-    op: /,|>>=|>>|\\\\|\\|\.|\+\+|\+|\-|\*\*|\*|===|!==|==|\/=|<=|>=|<|>|&&|\/|\|\||\.\.|\$|\^\^|\^|#|@|~|!!|!|%|\?|:|&|\||`/,
     assign: "=",
+    backslash: "\\",
+    pipe: "|",
+    at: "@",
+    tilde: "~",
+    anonymousVariable: "_",
     constructor: {
         match: /[A-Z][a-zA-Z0-9']*/,
-        type: moo.keywords({
-            typeClass: [
-                "Foldable",
-                "Bounded",
-                "Enum",
-                "Eq",
-                "Floating",
-                "Fractional",
-                "Functor",
-                "Integral",
-                "Ix",
-                "Monad",
-                "MonadPlus",
-                "Num",
-                "Ord",
-                "Random",
-                "RandomGen",
-                "Read",
-                "Real",
-                "RealFloat",
-                "RealFrac",
-                "Show",
-            ],
-        }),
+        type: moo.keywords({ bool: ["True", "False"] }),
     },
     variable: {
         match: /[a-z_][a-zA-Z0-9_']*/,
-        type: moo.keywords({
-            otherwise: "otherwise",
-            error: "error",
-            keyword: keywords,
-        }),
+        type: moo.keywords({ otherwise: "otherwise", keyword: keywords }),
     },
+    NL: { match: /\r?\n/, lineBreaks: true },
+    WS: { match: /[ \t]+/, lineBreaks: false },
 };
-export const HSLexer = makeLexer(HaskellLexerConfig, []);
-export const PreprocessorLexer = new IndentationLexer({
-    lexer: moo.compile(HaskellLexerConfig),
-    indentationType: "WS",
-    newlineType: 'NL',
-});
+export class HaskellLayoutLexer {
+    index;
+    mooLexer;
+    state;
+    layoutTriggers = new Set(["where", "let", "do", "of"]);
+    noSemicolonKeywords = new Set(["in", "then", "else", "of"]);
+    alwaysNewDeclarationKeywords = new Set([
+        "type",
+        "data",
+        "class",
+        "instance",
+        "describe",
+        "it",
+        "module",
+        "import",
+    ]);
+    constructor() {
+        this.mooLexer = moo.compile(HaskellLexerConfig);
+        this.state = {
+            stack: [1],
+            tokenBuffer: [],
+            expectingBlock: false,
+            firstTokenProcessed: false,
+        };
+    }
+    [Symbol.iterator]() {
+        return {
+            next: () => {
+                const value = this.next();
+                return value
+                    ? { value, done: false }
+                    : { value: undefined, done: true };
+            },
+        };
+    }
+    reset(chunk, state) {
+        if (state && state.layoutState) {
+            const fullState = state;
+            this.state = {
+                stack: [...fullState.layoutState.stack],
+                tokenBuffer: [...fullState.layoutState.tokenBuffer],
+                expectingBlock: fullState.layoutState.expectingBlock,
+                firstTokenProcessed: fullState.layoutState.firstTokenProcessed,
+            };
+            this.mooLexer.reset(chunk, fullState);
+            if (typeof fullState.mooIndex === "number") {
+                this.mooLexer.index = fullState.mooIndex;
+            }
+        }
+        else {
+            this.state = {
+                stack: [1],
+                tokenBuffer: [],
+                expectingBlock: false,
+                firstTokenProcessed: false,
+            };
+            this.mooLexer.reset(chunk);
+        }
+        return this;
+    }
+    save() {
+        return {
+            ...this.mooLexer.save(),
+            mooIndex: this.mooLexer.index,
+            layoutState: {
+                stack: [...this.state.stack],
+                tokenBuffer: [...this.state.tokenBuffer],
+                expectingBlock: this.state.expectingBlock,
+                firstTokenProcessed: this.state.firstTokenProcessed,
+            },
+        };
+    }
+    pushState(state) {
+        this.mooLexer.pushState(state);
+    }
+    popState() {
+        return this.mooLexer.popState();
+    }
+    setState(state) {
+        this.mooLexer.setState(state);
+    }
+    formatError(token, message) {
+        return this.mooLexer.formatError(token, message);
+    }
+    has(tokenType) {
+        return true; // deprecated in moo but Lexer interface requires it.
+    }
+    next() {
+        let token;
+        if (this.state.tokenBuffer.length > 0) {
+            token = this.state.tokenBuffer.shift();
+        }
+        else {
+            token = this.fetchAndProcessNextToken();
+        }
+        if (token) {
+            this.checkLayoutTrigger(token);
+            if (!this.state.firstTokenProcessed && token.col > 1) {
+                this.state.stack[0] = token.col;
+            }
+            this.state.firstTokenProcessed = true;
+        }
+        return token;
+    }
+    fetchAndProcessNextToken() {
+        let { token: rawToken, crossedNewline } = this.advanceSkippingWhitespace();
+        if (!rawToken)
+            return this.emitEOF();
+        if (this.state.expectingBlock)
+            return this.handleBlockStart(rawToken);
+        if (this.isInToken(rawToken))
+            return this.handleInKeyword(rawToken);
+        if (crossedNewline)
+            return this.handleIndentationChange(rawToken);
+        return rawToken;
+    }
+    advanceSkippingWhitespace() {
+        let token = this.mooLexer.next();
+        let crossedNewline = false;
+        while (token && this.isSkippableToken(token)) {
+            if (this.isNewlineToken(token))
+                crossedNewline = true;
+            token = this.mooLexer.next();
+        }
+        return { token, crossedNewline };
+    }
+    closeBlocksUntil(targetIndent, sourceToken) {
+        const ops = [];
+        while (this.state.stack.length > 1 &&
+            this.state.stack[this.state.stack.length - 1] > targetIndent) {
+            this.state.stack.pop();
+            ops.push(this.createVirtualToken("rbracket", "}", sourceToken));
+        }
+        const isAlwaysNewDeclaration = this.state.stack.length === 1 &&
+            sourceToken.type === "keyword" &&
+            this.alwaysNewDeclarationKeywords.has(sourceToken.value);
+        const shouldInjectSemicolon = !sourceToken.value || !this.noSemicolonKeywords.has(sourceToken.value);
+        if (this.state.stack.length > 1 &&
+            this.state.stack[this.state.stack.length - 1] === targetIndent &&
+            this.isInToken(sourceToken)) {
+            this.state.stack.pop();
+            ops.push(this.createVirtualToken("rbracket", "}", sourceToken));
+        }
+        else if ((this.state.stack.length > 0 &&
+            this.state.stack[this.state.stack.length - 1] === targetIndent &&
+            shouldInjectSemicolon) ||
+            isAlwaysNewDeclaration) {
+            ops.push(this.createVirtualToken("semicolon", ";", sourceToken));
+        }
+        this.state.tokenBuffer.unshift(...ops);
+        return this.state.tokenBuffer.shift();
+    }
+    emitEOF() {
+        if (this.state.stack.length > 1) {
+            const dummy = {
+                line: 0,
+                col: 0,
+                text: "",
+                value: "",
+                offset: 0,
+                lineBreaks: 0,
+            };
+            const ops = [];
+            while (this.state.stack.length > 1) {
+                this.state.stack.pop();
+                ops.push(this.createVirtualToken("rbracket", "}", dummy));
+            }
+            this.state.tokenBuffer.push(...ops);
+            return this.state.tokenBuffer.shift();
+        }
+        return undefined;
+    }
+    enqueue(token) {
+        this.state.tokenBuffer.push(token);
+    }
+    handleBlockStart(token) {
+        this.state.expectingBlock = false;
+        if (token.type === "lbracket")
+            return token;
+        this.state.stack.push(token.col);
+        this.enqueue(token);
+        return this.createVirtualToken("lbracket", "{", token);
+    }
+    handleInKeyword(token) {
+        const stackTop = this.state.stack[this.state.stack.length - 1];
+        if (token.col < stackTop) {
+            this.enqueue(token);
+            return this.closeBlocksUntil(token.col, token);
+        }
+        if (this.state.stack.length > 1) {
+            this.state.stack.pop();
+            this.enqueue(token);
+            return this.createVirtualToken("rbracket", "}", token);
+        }
+        return token;
+    }
+    handleIndentationChange(token) {
+        const currentIndent = token.col;
+        const stackTop = this.state.stack[this.state.stack.length - 1];
+        const isAlwaysNewDeclaration = this.state.stack.length === 1 &&
+            token.type === "keyword" &&
+            this.alwaysNewDeclarationKeywords.has(token.value);
+        if (currentIndent === stackTop || isAlwaysNewDeclaration) {
+            const isContinuationKeyword = token.value && this.noSemicolonKeywords.has(token.value);
+            if (this.state.firstTokenProcessed && !isContinuationKeyword) {
+                this.enqueue(token);
+                return this.createVirtualToken("semicolon", ";", token);
+            }
+            return token;
+        }
+        else if (currentIndent < stackTop) {
+            this.enqueue(token);
+            return this.closeBlocksUntil(currentIndent, token);
+        }
+        return token;
+    }
+    checkLayoutTrigger(token) {
+        if (token && token.value && this.layoutTriggers.has(token.value))
+            this.state.expectingBlock = true;
+    }
+    isSkippableToken(token) {
+        return (token.type === "WS" ||
+            this.isNewlineToken(token) ||
+            token.type === "comment");
+    }
+    isNewlineToken(token) {
+        return token.type === "NL";
+    }
+    isInToken(token) {
+        return token.type === "keyword" && token.value === "in";
+    }
+    createVirtualToken(type, value, source) {
+        return {
+            type,
+            value,
+            text: value,
+            line: source.line,
+            col: source.col,
+            offset: source.offset,
+            lineBreaks: 0,
+            toString: () => value,
+        };
+    }
+}
 //# sourceMappingURL=lexer.js.map

package/dist/parser/lexer.js.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parser/lexer.ts"],"names":[],"mappings":"AAAA,OAAO,GAAc,MAAM,KAAK,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,gBAAgB,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE;IACxC,iBAAiB,EAAE,GAAG;IACtB,EAAE,EAAE,MAAM;IACV,OAAO,EAAE,qBAAqB;IAC9B,MAAM,EACJ,4EAA4E;IAC9E,IAAI,EAAE,oDAAoD;IAC1D,MAAM,EAAE,oDAAoD;IAC5D,qCAAqC;IACrC,QAAQ,EAAE,GAAG;IACb,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,GAAG;IACX,QAAQ,EAAE,GAAG;IACb,QAAQ,EAAE,GAAG;IACb,OAAO,EAAE,GAAG;IACZ,OAAO,EAAE,GAAG;IACZ,aAAa,EAAE,IAAI;IACnB,SAAS,EAAE,GAAG;IACd,SAAS,EAAE,IAAI;IACf,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,GAAG;IACb,KAAK,EAAE,IAAI;IACX,IAAI,EAAE;QACJ,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;KACzB;IACD,EAAE,EAAE,qHAAqH;IACzH,MAAM,EAAE,GAAG;IACX,WAAW,EAAE;QACX,KAAK,EAAE,oBAAoB;QAC3B,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC;YACjB,SAAS,EAAE;gBACT,UAAU;gBACV,SAAS;gBACT,MAAM;gBACN,IAAI;gBACJ,UAAU;gBACV,YAAY;gBACZ,SAAS;gBACT,UAAU;gBACV,IAAI;gBACJ,OAAO;gBACP,WAAW;gBACX,KAAK;gBACL,KAAK;gBACL,QAAQ;gBACR,WAAW;gBACX,MAAM;gBACN,MAAM;gBACN,WAAW;gBACX,UAAU;gBACV,MAAM;aACP;SACF,CAAC;KACH;IACD,QAAQ,EAAE;QACR,KAAK,EAAE,sBAAsB;QAC7B,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC;YACjB,SAAS,EAAE,WAAW;YACtB,KAAK,EAAE,OAAO;YACd,OAAO,EAAE,QAAQ;SAClB,CAAC;KACH;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAU,SAAS,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;AAChE,MAAM,CAAC,MAAM,iBAAiB,GAAU,IAAI,gBAAgB,CAAC;IAC3D,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACtC,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,IAAI;CAClB,CAAC,CAAC"}
+{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parser/lexer.ts"],"names":[],"mappings":"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"}

package/dist/prelude.d.ts

@@ -1 +1 @@
-export declare const preludeCode = "data Ordering  = LT | EQ | GT\ndata Maybe a = Nothing | Just a\n(,) :: a -> b -> (a, b)\n(,) x y = (x, y)\n($) :: (a -> b) -> a -> b\n($) f x = f x\n(.) :: (b -> c) -> (a -> b) -> a -> c\n(.) f g a = (\\x -> f (g x)) a\n(:) :: a -> [a] -> [a]\n(:) x xs = x : xs\n(++) :: [a] -> [a] -> [a]\n(++) [] ys = ys\n(++) (x:xs) ys = x : (xs ++ ys)\n(&&) :: (Eq a) => a -> a -> Boolean\n(||) :: (Eq a) => a -> a -> Boolean\n(&&) x y = x && y\n(||) x y = x || y\n(==) :: (Ord a) => a -> a -> Boolean\n(/=) :: (Ord a) => a -> a -> Boolean\n(<) :: (Ord a) => a -> a -> Boolean\n(>) :: (Ord a) => a -> a -> Boolean\n(<=) :: (Ord a) => a -> a -> Boolean\n(>=) :: (Ord a) => a -> a -> Boolean\n(==) x y = x == y\n(/=) x y = x /= y\n(<) x y = x < y\n(>) x y = x > y\n(<=) x y = x <= y\n(>=) x y = x >= y\n(+) :: Num a => a -> a -> a\n(-) :: Num a => a -> a -> a\n(+) x y = x + y\n(-) x y = x - y\n(**) :: (Floating a) => a -> a -> a\n(**) x y = x ** y\n(^) :: (Num a, Integral b) => a -> b -> a\n(^) x y = x ^ y\n(^^) :: (Fractional a, Integral b) => a -> b -> a\n(^^) x y = x ^^ y\n(*) :: (Num a) => a -> a -> a\n(*) x y = x * y\n(/) :: Fractional a => a -> a -> a\n(/) _ 0 = error \"Prelude./: divide by zero\"\n(/) x y = x / y\n(!!) :: [a] -> Int -> a\n(!!) xs n | n < 0 = error \"Prelude.!!: negative index\"\n(!!) [] _ = error \"Prelude.!!: index too large\"\n(!!) (x:_) 0 = x\n(!!) (_:xs) n = xs !! (n - 1)\nnot :: Bool -> Bool\nnot True = False\nnot False = True\nquot :: Integral a => a -> a -> a\nquot _ 0 = error \"divide by zero\"\nquot 0 _ = 0\nquot a b = let { absA = abs a; absB = abs b; result = quotPositive absA absB } in if (a < 0) == (b < 0) then result else -result\nrem :: Integral a => a -> a -> a\nrem _ 0 = error \"divide by zero\"\nrem 0 _ = 0\nrem a b = let { absA = abs a; absB = abs b; remainder = remPositive absA absB } in if a < 0 then -remainder else remainder\nquotPositive :: Integral a => a -> a -> a\nquotPositive n d | n < d = 0 | otherwise = 1 + quotPositive (n - d) d\nremPositive :: Integral a => a -> a -> a\nremPositive n d | n < d = n | otherwise = remPositive (n - d) d\ndiv :: Integral a => a -> a -> a\ndiv _ 0 = error \"divide by zero\"\ndiv 0 _ = 0\ndiv a b = let { q = quot a b; r = rem a b } in if r == 0 || (a < 0) == (b < 0) then q else q - 1\nmod :: Integral a => a -> a -> a\nmod _ 0 = error \"divide by zero\"\nmod 0 _ = 0\nmod a b = a - (div a b) * b\nsignum :: (Num a) => a -> a\nsignum x | x == 0 = 0 | x > 0 = 1 | otherwise = -1\nabs :: (Num a) => a -> a\nabs n = if n < 0 then -n else n\nsqrt :: (Num a) => a -> a\nsqrt x = x ** 0.5\nmax :: a -> a -> a\nmax x y = if x <= y then y else x\nmin :: a -> a -> a\nmin x y = if x <= y then x else y\neven :: (Integral a) => a -> Bool\nodd :: (Integral a) => a -> Bool\neven n = n `rem` 2 == 0\nodd n = (not . even) n\nlength :: [a] -> Int\nlength [] = 0\nlength (_:l) = 1 + length l\ngenericLength :: (Integral a) => [b] -> a\ngenericLength [] = 0\ngenericLength (x:xs) = 1 + genericLength xs\nnull :: [a] -> Bool\nnull [] = True\nnull (_:_) = False\nunion :: (Eq a) => [a] -> [a] -> [a]\nunion xs ys = unionBy (==) xs ys\ndeleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]\ndeleteBy eq x [] = []\ndeleteBy eq x (y:ys) = if x `eq` y then ys else y : deleteBy eq x ys\ndeleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\ndeleteFirstsBy eq xs ys = foldl (flip (deleteBy eq)) xs ys\nnubBy :: (a -> a -> Bool) -> [a] -> [a]\nnubBy eq [] = []\nnubBy eq (x:xs) = x : nubBy eq (filter (\\y -> not (eq x y)) xs)\nunionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\nunionBy eq xs ys = xs ++ deleteFirstsBy eq (nubBy eq ys) xs\nintersect :: (Eq a) => [a] -> [a] -> [a]\nintersect xs ys = intersectBy (==) xs ys\nintersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\nintersectBy eq xs ys = [x | x <- xs, any (eq x) ys]\nelem :: (Eq a) => a -> [a] -> Bool\nnotElem :: (Eq a) => a -> [a] -> Bool\nelem x xs = any (\\y -> y == x) xs\nnotElem x xs = all (\\y -> y /= x) xs\nmaximum :: (Ord a) => [a] -> a\nminimum :: (Ord a) => [a] -> a\nmaximum [] = error \"Prelude.maximum: empty list\"\nmaximum xs = foldl1 max xs\nminimum [] = error \"Prelude.minimum: empty list\"\nminimum xs = foldl1 min xs\nsum :: (Num a) => [a] -> a\nproduct :: (Num a) => [a] -> a\nsum xs = foldl (+) 0 xs\nproduct xs = foldl (*) 1 xs\nconcat :: [[a]] -> [a]\nconcat xss = foldr (++) [] xss\nconcatMap :: (a -> [b]) -> [a] -> [b]\nconcatMap f xs = (concat . map) f xs\ntake :: Int -> [a] -> [a]\ntake n _ | n <= 0 = []\ntake _ [] = []\ntake n (x:xs) = x : take (n - 1) xs\ndrop :: Int -> [a] -> [a]\ndrop n xs | n <= 0 = xs\ndrop _ [] = []\ndrop n (_:xs) = drop (n - 1) xs\nhead :: [a] -> a\nhead (x:_) = x\nhead [] = error \"Prelude.head: empty list\"\ntail :: [a] -> [a]\ntail (_:xs) = xs\ntail [] = error \"Prelude.tail: empty list\"\nlast :: [a] -> a\nlast [x] = x\nlast (_:xs) = last xs\nlast [] = error \"Prelude.last: empty list\"\ninit :: [a] -> [a]\ninit [x] = []\ninit (x:xs) = x : init xs\ninit [] = error \"Prelude.init: empty list\"\nzip :: [a] -> [b] -> [(a, b)]\nzip xs ys = zipWith (,) xs ys\nzipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\nzipWith z (a:as) (b:bs) = z a b : zipWith z as bs\nzipWith _ _ _ = []\nreverse :: [a] -> [a]\nreverse xs = foldl (flip (:)) [] xs\nfilter :: (a -> Bool) -> [a] -> [a]\nfilter p [] = []\nfilter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs\nmap :: (a -> b) -> [a] -> [b]\nmap f [] = []\nmap f (x:xs) = f x : map f xs\nany :: (a -> Bool) -> [a] -> Bool\nall :: (a -> Bool) -> [a] -> Bool\nany f (x:xs) = f x || any f xs\nall f (x:xs) = f x && all f xs\nfoldl :: (a -> b -> a) -> a -> [b] -> a\nfoldl f z [] = z\nfoldl f z (x:xs) = foldl f (f z x) xs\nfoldl1 :: (a -> a -> a) -> [a] -> a\nfoldl1 f (x:xs) = foldl f x xs\nfoldl1 _ [] = error \"Prelude.foldl1: empty list\"\nfoldr :: (a -> b -> b) -> b -> [a] -> b\nfoldr f z [] = z\nfoldr f z (x:xs) = f x (foldr f z xs)\nfoldr1 :: (a -> a -> a) -> [a] -> a\nfoldr1 f [x] = x\nfoldr1 f (x:xs) = f x (foldr1 f xs)\nfoldr1 _ [] = error \"Prelude.foldr1: empty list\"\nfind :: Ord a => (a -> Bool) -> [a] -> Maybe a\nfind _ [] = Nothing\nfind f (x:xs) | f x = Just x | otherwise = find f xs\nsort :: (Ord a) => [a] -> [a]\nsort xs = sortBy compare xs\nsortBy :: (a -> a -> Ordering) -> [a] -> [a]\nsortBy cmp xs = foldr (insertBy cmp) [] xs\ncompare :: a -> a -> Ordering\ncompare x y | x == y = EQ | x <= y = LT | otherwise = GT\ninsertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]\ninsertBy cmp x [] = [x]\ninsertBy cmp x ys@(y:ys') = case cmp x y of { GT -> y : insertBy cmp x ys'; _ -> x : ys }\nflip :: (a -> b -> c) -> b -> a -> c\nflip f x y = f y x\nrepeat :: a -> [a]\nrepeat x = x : (repeat x)\niterate :: (a -> a) -> a -> [a]\niterate f x = x : iterate f (f x)\nreplicate :: Int -> a -> [a]\nreplicate n x = take n (repeat x)\ncycle :: [a] -> [a]\ncycle [] = error \"Prelude.cycle: empty list\"\ncycle xs = xs ++ (cycle xs)";
+export declare const preludeCode = "data Ordering  = LT | EQ | GT\ndata Maybe a = Nothing | Just a\nid :: a -> a\nid x = x\nconst :: a -> b -> a\nconst x _ = x\n(,) :: a -> b -> (a, b)\n(,) x y = (x, y)\n($) :: (a -> b) -> a -> b\n($) f x = f x\n($!) :: (a -> b) -> a -> b\n($!) f x = f x\n(.) :: (b -> c) -> (a -> b) -> a -> c\n(.) f g a = (\\x -> f (g x)) a\n(:) :: a -> [a] -> [a]\n(:) x xs = x : xs\n(++) :: [a] -> [a] -> [a]\n(++) [] ys = ys\n(++) (x:xs) ys = x : (xs ++ ys)\n(&&) :: Bool -> Bool -> Bool\n(||) :: Bool -> Bool -> Bool\n(&&) x y = x && y\n(||) x y = x || y\n(==) :: (Ord a) => a -> a -> Boolean\n(==) x y = x == y\n(/=) :: (Ord a) => a -> a -> Boolean\n(/=) x y = x /= y\n(<) :: (Ord a) => a -> a -> Boolean\n(<) x y = x < y\n(>) :: (Ord a) => a -> a -> Boolean\n(>) x y = x > y\n(<=) :: (Ord a) => a -> a -> Boolean\n(<=) x y = x <= y\n(>=) :: (Ord a) => a -> a -> Boolean\n(>=) x y = x >= y\n(+) :: Num a => a -> a -> a\n(-) :: Num a => a -> a -> a\n(+) x y = x + y\n(-) x y = x - y\n(**) :: (Floating a) => a -> a -> a\n(**) x y = x ** y\n(^) :: (Num a, Integral b) => a -> b -> a\n(^) x y = x ^ y\n(^^) :: (Fractional a, Integral b) => a -> b -> a\n(^^) x y = x ^^ y\n(*) :: (Num a) => a -> a -> a\n(*) x y = x * y\n(/) :: Fractional a => a -> a -> a\n(/) _ 0 = error \"Prelude./: divide by zero\"\n(/) x y = x / y\n(!!) :: [a] -> Int -> a\n(!!) xs n | n < 0 = error \"Prelude.!!: negative index\"\n(!!) [] _ = error \"Prelude.!!: index too large\"\n(!!) (x:_) 0 = x\n(!!) (_:xs) n = xs !! (n - 1)\nnot :: Bool -> Bool\nnot True = False\nnot False = True\nquot :: Integral a => a -> a -> a\nquot _ 0 = error \"divide by zero\"\nquot 0 _ = 0\nquot a b = let { absA = abs a; absB = abs b; result = quotPositive absA absB } in if (a < 0) == (b < 0) then result else -result\nrem :: Integral a => a -> a -> a\nrem _ 0 = error \"divide by zero\"\nrem 0 _ = 0\nrem a b = let { absA = abs a; absB = abs b; remainder = remPositive absA absB } in if a < 0 then -remainder else remainder\nquotPositive :: Integral a => a -> a -> a\nquotPositive n d | n < d = 0 | otherwise = 1 + quotPositive (n - d) d\nremPositive :: Integral a => a -> a -> a\nremPositive n d | n < d = n | otherwise = remPositive (n - d) d\ndiv :: Integral a => a -> a -> a\ndiv _ 0 = error \"divide by zero\"\ndiv 0 _ = 0\ndiv a b = let { q = quot a b; r = rem a b } in if r == 0 || (a < 0) == (b < 0) then q else q - 1\nmod :: Integral a => a -> a -> a\nmod _ 0 = error \"divide by zero\"\nmod 0 _ = 0\nmod a b = a - (div a b) * b\nsignum :: (Num a) => a -> a\nsignum x | x == 0 = 0 | x > 0 = 1 | otherwise = -1\nabs :: (Num a) => a -> a\nabs n = if n < 0 then -n else n\nsucc :: (Num a) => a -> a\nsucc x = x + 1\npred :: (Num a) => a -> a\npred x = x - 1\nsqrt :: (Num a) => a -> a\nsqrt x = x ** 0.5\nmax :: Ord a => a -> a -> a\nmax x y = if x <= y then y else x\nmin :: Ord a => a -> a -> a\nmin x y = if x <= y then x else y\neven :: (Integral a) => a -> Bool\nodd :: (Integral a) => a -> Bool\neven n = n `rem` 2 == 0\nodd n = (not . even) n\nlength :: [a] -> Int\nlength [] = 0\nlength (_:l) = 1 + length l\ngenericLength :: (Integral a) => [b] -> a\ngenericLength [] = 0\ngenericLength (x:xs) = 1 + genericLength xs\nnull :: [a] -> Bool\nnull [] = True\nnull (_:_) = False\nunion :: (Eq a) => [a] -> [a] -> [a]\nunion xs ys = unionBy (==) xs ys\ndeleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]\ndeleteBy eq x [] = []\ndeleteBy eq x (y:ys) = if x `eq` y then ys else y : deleteBy eq x ys\ndeleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\ndeleteFirstsBy eq xs ys = foldl (flip (deleteBy eq)) xs ys\nnubBy :: (a -> a -> Bool) -> [a] -> [a]\nnubBy eq [] = []\nnubBy eq (x:xs) = x : nubBy eq (filter (\\y -> not (eq x y)) xs)\nunionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\nunionBy eq xs ys = xs ++ deleteFirstsBy eq (nubBy eq ys) xs\nintersect :: (Eq a) => [a] -> [a] -> [a]\nintersect xs ys = intersectBy (==) xs ys\nintersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]\nintersectBy eq xs ys = [x | x <- xs, any (eq x) ys]\nelem :: (Eq a) => a -> [a] -> Bool\nnotElem :: (Eq a) => a -> [a] -> Bool\nelem x xs = any (\\y -> y == x) xs\nnotElem x xs = all (\\y -> y /= x) xs\nmaximum :: (Ord a) => [a] -> a\nminimum :: (Ord a) => [a] -> a\nmaximum [] = error \"Prelude.maximum: empty list\"\nmaximum xs = foldl1 max xs\nminimum [] = error \"Prelude.minimum: empty list\"\nminimum xs = foldl1 min xs\nsum :: (Num a) => [a] -> a\nproduct :: (Num a) => [a] -> a\nsum xs = foldl (+) 0 xs\nproduct xs = foldl (*) 1 xs\nconcat :: [[a]] -> [a]\nconcat xss = foldr (++) [] xss\nconcatMap :: (a -> [b]) -> [a] -> [b]\nconcatMap f xs = (concat . map) f xs\ntake :: Int -> [a] -> [a]\ntake n _ | n <= 0 = []\ntake _ [] = []\ntake n (x:xs) = x : take (n - 1) xs\ndrop :: Int -> [a] -> [a]\ndrop n xs | n <= 0 = xs\ndrop _ [] = []\ndrop n (_:xs) = drop (n - 1) xs\nhead :: [a] -> a\nhead (x:_) = x\nhead [] = error \"Prelude.head: empty list\"\ntail :: [a] -> [a]\ntail (_:xs) = xs\ntail [] = error \"Prelude.tail: empty list\"\nlast :: [a] -> a\nlast [x] = x\nlast (_:xs) = last xs\nlast [] = error \"Prelude.last: empty list\"\ninit :: [a] -> [a]\ninit [x] = []\ninit (x:xs) = x : init xs\ninit [] = error \"Prelude.init: empty list\"\nzip :: [a] -> [b] -> [(a, b)]\nzip xs ys = zipWith (,) xs ys\nzipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\nzipWith z (a:as) (b:bs) = z a b : zipWith z as bs\nzipWith _ _ _ = []\nreverse :: [a] -> [a]\nreverse xs = foldl (flip (:)) [] xs\nfilter :: (a -> Bool) -> [a] -> [a]\nfilter p [] = []\nfilter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs\nmap :: (a -> b) -> [a] -> [b]\nmap f [] = []\nmap f (x:xs) = f x : map f xs\nany :: (a -> Bool) -> [a] -> Bool\nany f [] = False\nany f (x:xs) = f x || any f xs\nall :: (a -> Bool) -> [a] -> Bool\nall f [] = True\nall f (x:xs) = f x && all f xs\nfoldl :: (a -> b -> a) -> a -> [b] -> a\nfoldl f z [] = z\nfoldl f z (x:xs) = foldl f (f z x) xs\nfoldl1 :: (a -> a -> a) -> [a] -> a\nfoldl1 f (x:xs) = foldl f x xs\nfoldl1 _ [] = error \"Prelude.foldl1: empty list\"\nfoldr :: (a -> b -> b) -> b -> [a] -> b\nfoldr f z [] = z\nfoldr f z (x:xs) = f x (foldr f z xs)\nfoldr1 :: (a -> a -> a) -> [a] -> a\nfoldr1 f [x] = x\nfoldr1 f (x:xs) = f x (foldr1 f xs)\nfoldr1 _ [] = error \"Prelude.foldr1: empty list\"\nfind :: Ord a => (a -> Bool) -> [a] -> Maybe a\nfind _ [] = Nothing\nfind f (x:xs) | f x = Just x | otherwise = find f xs\nsort :: (Ord a) => [a] -> [a]\nsort xs = sortBy compare xs\nsortBy :: (a -> a -> Ordering) -> [a] -> [a]\nsortBy cmp xs = foldr (insertBy cmp) [] xs\ncompare :: Ord a => a -> a -> Ordering\ncompare x y | x == y = EQ | x <= y = LT | otherwise = GT\ninsertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]\ninsertBy cmp x [] = [x]\ninsertBy cmp x ys@(y:ys') = case cmp x y of { GT -> y : insertBy cmp x ys'; _ -> x : ys }\nflip :: (a -> b -> c) -> b -> a -> c\nflip f x y = f y x\nrepeat :: a -> [a]\nrepeat x = x : (repeat x)\niterate :: (a -> a) -> a -> [a]\niterate f x = x : iterate f (f x)\nreplicate :: Int -> a -> [a]\nreplicate n x = take n (repeat x)\ncycle :: [a] -> [a]\ncycle [] = error \"Prelude.cycle: empty list\"\ncycle xs = xs ++ (cycle xs)\nfst :: (a,b) -> a\nfst (x,_) = x\nsnd :: (a,b) -> b\nsnd (_,y) = y\nbetween :: Ord a => a -> a -> a -> Bool\nbetween m n p | n >= m && n <= p = True | otherwise = False\ntruncate :: (Num a, Integral b) => a -> b\ntruncate x = quot x 1\nfloor :: (Num a, Integral b) => a -> b\nfloor x = div x 1\nnegate :: Num a => a -> a\nnegate n = 0 - n\nceiling :: (Num a, Integral b) => a -> b\nceiling x = negate (floor (negate x))\nround :: (Num a, Integral b) => a -> b\nround x | r < 0.5 = n | r > 0.5 = n + 1 | even n = n | otherwise = n + 1 where { n = floor x; r = x - n }\ndropWhile :: (a -> Bool) -> [a] -> [a]\ndropWhile _ [] = []\ndropWhile p xs@(x:xs') | p x = dropWhile p xs' | otherwise = xs\nbreak :: (a -> Bool) -> [a] -> ([a], [a])\nbreak _ [] = ([], [])\nbreak p (x:xs) | p x = ([], x:xs) | otherwise = (x : fst (break p xs), snd (break p xs))\nwords :: String -> [String]\nwords s = let { sTrim = dropWhile (\\c -> c == ' ') s } in if null sTrim then [] else fst (break (\\c -> c == ' ') sTrim) : words (snd (break (\\c -> c == ' ') sTrim))\nintersperse :: a -> [a] -> [a]\nintersperse _ [] = []\nintersperse _ [x] = [x]\nintersperse sep (x:xs) = x : sep : intersperse sep xs\nintercalate :: [a] -> [[a]] -> [a]\nintercalate xs xss = concat (intersperse xs xss)\nfromIntegral :: (Integral a, Num b) => a -> b\nfromIntegral x = x \n\nanyException = \"\"\nevaluate x = x\n\nclass Show a where\n  show :: a -> String\n\ninstance Show Int where\n  show x = primShow x\n\ninstance Show Bool where\n  show True = \"True\"\n  show False = \"False\"\n\ninstance Show Ordering where\n  show LT = \"LT\"\n  show EQ = \"EQ\"\n  show GT = \"GT\"\n\ninstance Show (Maybe a) where\n  show Nothing = \"Nothing\"\n  show (Just x) = \"Just \" ++ show x\n\ninstance Show Char where\n  show c = '\\'' : c : '\\'' : []\n\ninstance Show String where\n  show s = primShowString s\n\ninstance Show [a] where\n  show xs = '[' : (intercalate \",\" (map show xs) ++ \"]\")\n";