purescript-prepack.js

var PS;
(function () {
    "use strict";

    var _$0 = this;

    var _$1 = Object.setPrototypeOf;

    function _2(fs) {
        return function (xs) {
            var result = [];
            var n = 0;

            for (var i = 0, l = fs.length; i < l; i++) {
                for (var j = 0, k = xs.length; j < k; j++) {
                    result[n++] = fs[i](xs[j]);
                }
            }

            return result;
        };
    }

    function _3(Functor0, apply) {
        this.Functor0 = Functor0;
        this.apply = apply;
    }

    var _1W = _3.prototype;

    function _4(dict) {
        return dict.apply;
    }

    function _6() {
        return _7.functorArray;
    }

    function _8(f) {
        return function (arr) {
            var l = arr.length;
            var result = new _$0.Array(l);

            for (var i = 0; i < l; i++) {
                result[i] = f(arr[i]);
            }

            return result;
        };
    }

    function _9(map) {
        this.map = map;
    }

    var _1V = _9.prototype;

    function _a(dict) {
        return dict.map;
    }

    function _d(compose) {
        this.compose = compose;
    }

    var _1X = _d.prototype;

    function _e(dict) {
        return dict.compose;
    }

    function _g(f) {
        return function (g) {
            return function (x) {
                return f(g(x));
            };
        };
    }

    function _i(Semigroupoid0, id) {
        this.Semigroupoid0 = Semigroupoid0;
        this.id = id;
    }

    var _1Y = _i.prototype;

    function _j(dict) {
        return dict.id;
    }

    function _l() {
        return _c.semigroupoidFn;
    }

    function _m(x) {
        return x;
    }

    function _o(a) {
        return function (v) {
            return a;
        };
    }

    function _p(f) {
        return function (b) {
            return function (a) {
                return f(a)(b);
            };
        };
    }

    function _t(n) {
        return n.toString();
    }

    function _u(f) {
        return function (xs) {
            var ss = [];

            for (var i = 0, l = xs.length; i < l; i++) {
                ss[i] = f(xs[i]);
            }

            return "[" + ss.join(",") + "]";
        };
    }

    function _v(show) {
        this.show = show;
    }

    var _1Z = _v.prototype;

    function _w(dict) {
        return dict.show;
    }

    function _y(dictShow) {
        return new _v(_s.showArrayImpl(_w(dictShow)));
    }

    function _A(Apply0, pure) {
        this.Apply0 = Apply0;
        this.pure = pure;
    }

    var _20 = _A.prototype;

    function _B(dict) {
        return dict.pure;
    }

    function _D() {
        return _1.applyArray;
    }

    function _E(x) {
        return [x];
    }

    function _G(s) {
        return function () {
            _$0.console.log(s);

            return {};
        };
    }

    function _H(dictShow) {
        return function (a) {
            return _F.log(_s.show(dictShow)(a));
        };
    }

    function _J(r1) {
        return function (r2) {
            return r1 === r2;
        };
    }

    function _K(f) {
        return function (xs) {
            return function (ys) {
                if (xs.length !== ys.length) return false;

                for (var i = 0; i < xs.length; i++) {
                    if (!f(xs[i])(ys[i])) return false;
                }

                return true;
            };
        };
    }

    function _L(eq) {
        this.eq = eq;
    }

    var _21 = _L.prototype;

    function _M(dict) {
        return dict.eq;
    }

    function _Q(v) {
        return function (v1) {
            return true;
        };
    }

    function _R(dictEq) {
        return new _L(_I.eqArrayImpl(_M(dictEq)));
    }

    function _T(f) {
        return function (init) {
            return function (xs) {
                var acc = init;
                var len = xs.length;

                for (var i = len - 1; i >= 0; i--) {
                    acc = f(xs[i])(acc);
                }

                return acc;
            };
        };
    }

    function _U(f) {
        return function (init) {
            return function (xs) {
                var acc = init;
                var len = xs.length;

                for (var i = 0; i < len; i++) {
                    acc = f(acc)(xs[i]);
                }

                return acc;
            };
        };
    }

    function _V(foldMap, foldl, foldr) {
        this.foldMap = foldMap;
        this.foldl = foldl;
        this.foldr = foldr;
    }

    var _22 = _V.prototype;

    function _W(dict) {
        return dict.foldMap;
    }

    function _X(dictFoldable) {
        return function (dictMonoid) {
            return function (f) {
                return _Y(dictFoldable)(function (x) {
                    return function (acc) {
                        return _Z.append(dictMonoid.Semigroup0())(f(x))(acc);
                    };
                })(_11.mempty(dictMonoid));
            };
        };
    }

    function _Y(dict) {
        return dict.foldr;
    }

    function _10(dict) {
        return dict.append;
    }

    function _12(dict) {
        return dict.mempty;
    }

    function _13(dict) {
        return dict.foldl;
    }

    function _15(dictMonoid) {
        return _X(_14)(dictMonoid);
    }

    function _17() {}

    var _23 = _17.prototype;

    function _19(value0) {
        this.value0 = value0;
    }

    function _1a(value0) {
        return new _19(value0);
    }

    function _1b(dictPartial) {
        return function (v) {
            var __unused = function (dictPartial1) {
                return function ($dollar34) {
                    return $dollar34;
                };
            };

            return __unused(dictPartial)(function () {
                if (v instanceof _19) {
                    return v.value0;
                }

                ;
                throw new _$0.Error("Failed pattern match at Data.Maybe line 271, column 1 - line 271, column 21: " + [v.constructor.name]);
            }());
        };
    }

    function _1c(v2) {
        if (v2 instanceof _17) {
            return true;
        }

        ;

        if (v2 instanceof _19) {
            return _1d(v2.value0);
        }

        ;
        throw new _$0.Error("Failed pattern match at Data.Maybe line 220, column 1 - line 220, column 22: " + [true.constructor.name, _1d.constructor.name, v2.constructor.name]);
    }

    function _1d(v) {
        return false;
    }

    function _1e(v) {
        return function (v1) {
            return function (v2) {
                if (v2 instanceof _17) {
                    return v;
                }

                ;

                if (v2 instanceof _19) {
                    return v1(v2.value0);
                }

                ;
                throw new _$0.Error("Failed pattern match at Data.Maybe line 220, column 1 - line 220, column 22: " + [v.constructor.name, v1.constructor.name, v2.constructor.name]);
            };
        };
    }

    function _1g(v) {
        return function (v1) {
            if (v1 instanceof _19) {
                return new _19(v(v1.value0));
            }

            ;
            return _17.value;
        };
    }

    function _1i(apply) {
        return function (map) {
            return function (pure) {
                return function (f) {
                    var buildFrom = function (x, ys) {
                        return apply(map(_1j)(f(x)))(ys);
                    };

                    var go = function (acc, currentLen, xs) {
                        if (currentLen === 0) {
                            return acc;
                        } else {
                            var last = xs[currentLen - 1];
                            return new _1l(function () {
                                return go(buildFrom(last, acc), currentLen - 1, xs);
                            });
                        }
                    };

                    return function (array) {
                        var result = go(pure(_1m), array.length, array);

                        while (result instanceof _1l) {
                            result = result.fn();
                        }

                        return map(_1n)(result);
                    };
                };
            };
        };
    }

    function _1j(x) {
        return function (xs) {
            return new _1k(x, xs);
        };
    }

    function _1k(head, tail) {
        this.head = head;
        this.tail = tail;
    }

    function _1l(fn) {
        this.fn = fn;
    }

    function _1n(list) {
        var arr = [];
        var xs = list;

        while (xs !== _1m) {
            arr.push(xs.head);
            xs = xs.tail;
        }

        return arr;
    }

    function _1o(Foldable1, Functor0, sequence, traverse) {
        this.Foldable1 = Foldable1;
        this.Functor0 = Functor0;
        this.sequence = sequence;
        this.traverse = traverse;
    }

    var _24 = _1o.prototype;

    function _1p(dict) {
        return dict.sequence;
    }

    function _1q(dictTraversable) {
        return function (dictApplicative) {
            return _1r(dictTraversable)(dictApplicative)(_h.id(_h.categoryFn));
        };
    }

    function _1r(dict) {
        return dict.traverse;
    }

    function _1t() {
        return _S.foldableArray;
    }

    function _1u() {
        return _7.functorArray;
    }

    function _1v(dictApplicative) {
        return _1q(_1s)(dictApplicative);
    }

    function _1w(dictApplicative) {
        return _1h.traverseArrayImpl(_1.apply(dictApplicative.Apply0()))(_7.map(dictApplicative.Apply0().Functor0()))(_z.pure(dictApplicative));
    }

    function _1y(value0, value1) {
        this.value0 = value0;
        this.value1 = value1;
    }

    function _1z(value0) {
        return function (value1) {
            return new _1y(value0, value1);
        };
    }

    function _1A(v) {
        return v.value0;
    }

    function _1B(v) {
        return v.value1;
    }

    function _1D(isNothing) {
        return function (fromJust) {
            return function (fst) {
                return function (snd) {
                    return function (f) {
                        return function (b) {
                            var result = [];
                            var value = b;

                            while (true) {
                                // eslint-disable-line no-constant-condition
                                var maybe = f(value);
                                if (isNothing(maybe)) return result;
                                var tuple = fromJust(maybe);
                                result.push(fst(tuple));
                                value = snd(tuple);
                            }
                        };
                    };
                };
            };
        };
    }

    function _1E(unfoldr) {
        this.unfoldr = unfoldr;
    }

    var _25 = _1E.prototype;

    function _1F(dictUnfoldable) {
        return _1G(dictUnfoldable)(function (b) {
            return _7.map(_16.functorMaybe)(_n.flip(_1x.Tuple.create)(_16.Nothing.value))(b);
        });
    }

    function _1G(dict) {
        return dict.unfoldr;
    }

    function _1H(dictUnfoldable) {
        return _1G(dictUnfoldable)(_n["const"](_16.Nothing.value))(_q.unit);
    }

    function _1I(dictUnfoldable) {
        return function (n) {
            return function (v) {
                var step = function (i) {
                    var $8 = i <= 0;

                    if ($8) {
                        return _16.Nothing.value;
                    }

                    ;
                    return new _16.Just(new _1x.Tuple(v, i - 1 | 0));
                };

                return _1G(dictUnfoldable)(step)(n);
            };
        };
    }

    function _1J(dictApplicative) {
        return function (dictUnfoldable) {
            return function (dictTraversable) {
                return function (n) {
                    return function (m) {
                        return _1h.sequence(dictTraversable)(dictApplicative)(_1I(dictUnfoldable)(n)(m));
                    };
                };
            };
        };
    }

    function _1K(dictUnfoldable) {
        return _1I(dictUnfoldable)(1);
    }

    function _1M(f) {
        return function (b) {
            var result = [];
            var value = b;

            while (true) {
                var maybe = f(value);
                if (_1c(maybe)) return result;

                var tuple = _1N(maybe);

                result.push(_1A(tuple));
                value = _1B(tuple);
            }
        };
    }

    function _1N(v) {
        var __unused = function (dictPartial1) {
            return function ($dollar34) {
                return $dollar34;
            };
        };

        return __unused(undefined)(function () {
            if (v instanceof _19) {
                return v.value0;
            }

            ;
            throw new _$0.Error("Failed pattern match at Data.Maybe line 271, column 1 - line 271, column 21: " + [v.constructor.name]);
        }());
    }

    function _1P(message) {
        return function (success) {
            return function () {
                if (!success) throw new _$0.Error(message);
                return {};
            };
        };
    }

    function _1Q(success) {
        return function () {
            if (!success) throw new _$0.Error("Assertion failed");
            return {};
        };
    }

    function _1S(b) {
        var result = [];
        var value = b;

        while (true) {
            var maybe = _1T(value);

            if (_1c(maybe)) return result;

            var tuple = _1N(maybe);

            result.push(_1A(tuple));
            value = _1B(tuple);
        }
    }

    function _1T(v) {
        if (v === 1) {
            return _16.Nothing.value;
        }

        ;
        return _16.Just.create(_1x.Tuple.create(v)(function () {
            var $2 = v % 2 === 0;

            if ($2) {
                return v / 2 | 0;
            }

            ;
            return (v * 3 | 0) + 1 | 0;
        }()));
    }

    function _1U() {
        _F.log("Collatz 1000")();

        _F.logShow(_s.showArray(_s.showInt))(_1S(1000))();

        _F.log("Test none")();

        _1O.assert(_I.eq(_I.eqArray(_I.eqUnit))(_1C.none(_1C.unfoldableArray))([]))();

        _F.log("Test singleton")();

        _1O.assert(_I.eq(_I.eqArray(_I.eqUnit))(_1C.singleton(_1C.unfoldableArray)(_q.unit))([_q.unit]))();

        _F.log("Test replicate")();

        _1O.assert(_I.eq(_I.eqArray(_I.eqString))(_1C.replicate(_1C.unfoldableArray)(3)("foo"))(["foo", "foo", "foo"]))();

        _F.log("Test replicateA")();

        _1O.assert(_I.eq(_I.eqArray(_I.eqArray(_I.eqInt)))(_1C.replicateA(_z.applicativeArray)(_1C.unfoldableArray)(_1h.traversableArray)(3)([1, 2]))([[1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 2, 2], [2, 1, 1], [2, 1, 2], [2, 2, 1], [2, 2, 2]]))();

        _F.log("Test Maybe.toUnfoldable")();

        _1O.assert(_I.eq(_I.eqArray(_I.eqString))(_1C.fromMaybe(_1C.unfoldableArray)(new _16.Just("a")))(["a"]))();

        _1O.assert(_I.eq(_I.eqArray(_I.eqString))(_1C.fromMaybe(_1C.unfoldableArray)(_16.Nothing.value))([]))();

        return _F.log("All done!")();
    }

    PS = undefined;
    var _b = {
        map: _8
    };
    var _7 = {
        arrayMap: _8,
        Functor: _9,
        map: _a,
        functorArray: _b
    };
    var _5 = {
        Functor0: _6,
        apply: _2
    };
    var _1 = {
        arrayApply: _2,
        Apply: _3,
        apply: _4,
        applyArray: _5
    };
    var _f = {
        compose: _g
    };
    var _c = {
        Semigroupoid: _d,
        compose: _e,
        semigroupoidFn: _f
    };
    var _k = {
        Semigroupoid0: _l,
        id: _m
    };
    var _h = {
        Category: _i,
        id: _j,
        categoryFn: _k
    };
    var _n = {
        "const": _o,
        flip: _p
    };
    var _q = {
        unit: {}
    };
    var _x = {
        show: _t
    };
    var _s = {
        showIntImpl: _t,
        showArrayImpl: _u,
        Show: _v,
        show: _w,
        showInt: _x,
        showArray: _y
    };
    var _C = {
        Apply0: _D,
        pure: _E
    };
    var _z = {
        Applicative: _A,
        pure: _B,
        applicativeArray: _C
    };
    var _F = {
        log: _G,
        logShow: _H
    };
    var _N = {
        eq: _J
    };
    var _O = {
        eq: _J
    };
    var _P = {
        eq: _Q
    };
    var _I = {
        refEq: _J,
        eqArrayImpl: _K,
        Eq: _L,
        eq: _M,
        eqInt: _N,
        eqString: _O,
        eqUnit: _P,
        eqArray: _R
    };
    var _Z = {
        append: _10
    };
    var _11 = {
        mempty: _12
    };
    var _14 = {
        foldMap: _15,
        foldl: _U,
        foldr: _T
    };
    var _S = {
        foldrArray: _T,
        foldlArray: _U,
        Foldable: _V,
        foldMap: _W,
        foldMapDefaultR: _X,
        foldl: _13,
        foldr: _Y,
        foldableArray: _14
    };
    var _18 = {};
    _17.value = _18;
    _19.create = _1a;
    var _1f = {
        map: _1g
    };
    var _16 = {
        Nothing: _17,
        Just: _19,
        fromJust: _1b,
        isNothing: _1c,
        maybe: _1e,
        functorMaybe: _1f
    };
    var _1m = {};
    var _1s = {
        Foldable1: _1t,
        Functor0: _1u,
        sequence: _1v,
        traverse: _1w
    };
    var _1h = {
        traverseArrayImpl: _1i,
        Traversable: _1o,
        sequence: _1p,
        sequenceDefault: _1q,
        traverse: _1r,
        traversableArray: _1s
    };
    _1y.create = _1z;
    var _1x = {
        Tuple: _1y,
        fst: _1A,
        snd: _1B
    };
    var _1L = {
        unfoldr: _1M
    };
    var _1C = {
        unfoldrArrayImpl: _1D,
        Unfoldable: _1E,
        fromMaybe: _1F,
        none: _1H,
        replicate: _1I,
        replicateA: _1J,
        singleton: _1K,
        unfoldr: _1G,
        unfoldableArray: _1L
    };
    var _1O = {
        "assert'": _1P,
        assert: _1Q
    };

    _$1(_O, _21);

    _$1(_P, _21);

    _$1(_1f, _1V);

    _$1(_1L, _25);

    _$1(_1s, _24);

    _$1(_18, _23);

    _$1(_14, _22);

    _$1(_N, _21);

    _$1(_C, _20);

    _$1(_x, _1Z);

    _$1(_k, _1Y);

    _$1(_f, _1X);

    _$1(_5, _1W);

    _$1(_b, _1V);

    PS = {
        "Control.Apply": _1,
        "Control.Semigroupoid": _c,
        "Control.Category": _h,
        "Data.Function": _n,
        "Data.Functor": _7,
        "Data.Unit": _q,
        "Data.Show": _s,
        "Control.Applicative": _z,
        "Control.Monad.Eff.Console": _F,
        "Data.Eq": _I,
        "Data.Foldable": _S,
        "Data.Semigroup": _Z,
        "Data.Monoid": _11,
        "Data.Maybe": _16,
        "Data.Traversable": _1h,
        "Data.Tuple": _1x,
        "Data.Unfoldable": _1C,
        "Test.Assert": _1O,
        "Test.Main": {
            collatz: _1S,
            main: _1U
        }
    };
    console.log("Collatz 1000");
    console.log("[1000,500,250,125,376,188,94,47,142,71,214,107,322,161,484,242,121,364,182,91,274,137,412,206,103,310,155,466,233,700,350,175,526,263,790,395,1186,593,1780,890,445,1336,668,334,167,502,251,754,377,1132,566,283,850,425,1276,638,319,958,479,1438,719,2158,1079,3238,1619,4858,2429,7288,3644,1822,911,2734,1367,4102,2051,6154,3077,9232,4616,2308,1154,577,1732,866,433,1300,650,325,976,488,244,122,61,184,92,46,23,70,35,106,53,160,80,40,20,10,5,16,8,4,2]");
    console.log("Test none");
    console.log("Test singleton");
    console.log("Test replicate");
    console.log("Test replicateA");
    console.log("Test Maybe.toUnfoldable");
    console.log("All done!");
}).call(this);