create-beater-index
Version:
beater index generator
1,558 lines (1,500 loc) • 142 kB
JavaScript
// Generated by purs bundle 0.12.3
var PS = {};
(function(exports) {
"use strict";
exports.arrayBind = function (arr) {
return function (f) {
var result = [];
for (var i = 0, l = arr.length; i < l; i++) {
Array.prototype.push.apply(result, f(arr[i]));
}
return result;
};
};
})(PS["Control.Bind"] = PS["Control.Bind"] || {});
(function(exports) {
"use strict";
exports.arrayApply = function (fs) {
return function (xs) {
var l = fs.length;
var k = xs.length;
var result = new Array(l*k);
var n = 0;
for (var i = 0; i < l; i++) {
var f = fs[i];
for (var j = 0; j < k; j++) {
result[n++] = f(xs[j]);
}
}
return result;
};
};
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Semigroupoid = function (compose) {
this.compose = compose;
};
var semigroupoidFn = new Semigroupoid(function (f) {
return function (g) {
return function (x) {
return f(g(x));
};
};
});
var compose = function (dict) {
return dict.compose;
};
exports["compose"] = compose;
exports["Semigroupoid"] = Semigroupoid;
exports["semigroupoidFn"] = semigroupoidFn;
})(PS["Control.Semigroupoid"] = PS["Control.Semigroupoid"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Category = function (Semigroupoid0, identity) {
this.Semigroupoid0 = Semigroupoid0;
this.identity = identity;
};
var identity = function (dict) {
return dict.identity;
};
var categoryFn = new Category(function () {
return Control_Semigroupoid.semigroupoidFn;
}, function (x) {
return x;
});
exports["Category"] = Category;
exports["identity"] = identity;
exports["categoryFn"] = categoryFn;
})(PS["Control.Category"] = PS["Control.Category"] || {});
(function(exports) {
"use strict";
exports.refEq = function (r1) {
return function (r2) {
return r1 === r2;
};
};
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Symbol"];
var SProxy = (function () {
function SProxy() {
};
SProxy.value = new SProxy();
return SProxy;
})();
var IsSymbol = function (reflectSymbol) {
this.reflectSymbol = reflectSymbol;
};
var reflectSymbol = function (dict) {
return dict.reflectSymbol;
};
exports["IsSymbol"] = IsSymbol;
exports["reflectSymbol"] = reflectSymbol;
exports["SProxy"] = SProxy;
})(PS["Data.Symbol"] = PS["Data.Symbol"] || {});
(function(exports) {
"use strict";
exports.unit = {};
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function(exports) {
"use strict";
exports.unsafeGet = function (label) {
return function (rec) {
return rec[label];
};
};
exports.unsafeDelete = function (label) {
return function (rec) {
var copy = {};
for (var key in rec) {
if (key !== label && {}.hasOwnProperty.call(rec, key)) {
copy[key] = rec[key];
}
}
return copy;
};
};
})(PS["Record.Unsafe"] = PS["Record.Unsafe"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Record.Unsafe"];
exports["unsafeGet"] = $foreign.unsafeGet;
exports["unsafeDelete"] = $foreign.unsafeDelete;
})(PS["Record.Unsafe"] = PS["Record.Unsafe"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var RLProxy = (function () {
function RLProxy() {
};
RLProxy.value = new RLProxy();
return RLProxy;
})();
exports["RLProxy"] = RLProxy;
})(PS["Type.Data.RowList"] = PS["Type.Data.RowList"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Show"];
var Data_Symbol = PS["Data.Symbol"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Show = function (show) {
this.show = show;
};
var show = function (dict) {
return dict.show;
};
exports["Show"] = Show;
exports["show"] = show;
})(PS["Data.Show"] = PS["Data.Show"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Unit"];
var Data_Show = PS["Data.Show"];
exports["unit"] = $foreign.unit;
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Eq"];
var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Data_Void = PS["Data.Void"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Eq = function (eq) {
this.eq = eq;
};
var eqString = new Eq($foreign.refEq);
var eqInt = new Eq($foreign.refEq);
var eqChar = new Eq($foreign.refEq);
var eqBoolean = new Eq($foreign.refEq);
var eq = function (dict) {
return dict.eq;
};
var notEq = function (dictEq) {
return function (x) {
return function (y) {
return eq(eqBoolean)(eq(dictEq)(x)(y))(false);
};
};
};
exports["Eq"] = Eq;
exports["eq"] = eq;
exports["notEq"] = notEq;
exports["eqBoolean"] = eqBoolean;
exports["eqInt"] = eqInt;
exports["eqChar"] = eqChar;
exports["eqString"] = eqString;
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function(exports) {
"use strict";
exports.unsafeCompareImpl = function (lt) {
return function (eq) {
return function (gt) {
return function (x) {
return function (y) {
return x < y ? lt : x === y ? eq : gt;
};
};
};
};
};
})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
(function(exports) {
"use strict";
exports.concatString = function (s1) {
return function (s2) {
return s1 + s2;
};
};
exports.concatArray = function (xs) {
return function (ys) {
if (xs.length === 0) return ys;
if (ys.length === 0) return xs;
return xs.concat(ys);
};
};
})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Semigroup"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Data_Void = PS["Data.Void"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Semigroup = function (append) {
this.append = append;
};
var semigroupString = new Semigroup($foreign.concatString);
var semigroupArray = new Semigroup($foreign.concatArray);
var append = function (dict) {
return dict.append;
};
exports["Semigroup"] = Semigroup;
exports["append"] = append;
exports["semigroupString"] = semigroupString;
exports["semigroupArray"] = semigroupArray;
})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Data_Eq = PS["Data.Eq"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Show = PS["Data.Show"];
var LT = (function () {
function LT() {
};
LT.value = new LT();
return LT;
})();
var GT = (function () {
function GT() {
};
GT.value = new GT();
return GT;
})();
var EQ = (function () {
function EQ() {
};
EQ.value = new EQ();
return EQ;
})();
exports["LT"] = LT;
exports["GT"] = GT;
exports["EQ"] = EQ;
})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Ord.Unsafe"];
var Data_Ordering = PS["Data.Ordering"];
var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
exports["unsafeCompare"] = unsafeCompare;
})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
(function(exports) {
"use strict";
exports.intSub = function (x) {
return function (y) {
/* jshint bitwise: false */
return x - y | 0;
};
};
})(PS["Data.Ring"] = PS["Data.Ring"] || {});
(function(exports) {
"use strict";
exports.intAdd = function (x) {
return function (y) {
/* jshint bitwise: false */
return x + y | 0;
};
};
exports.intMul = function (x) {
return function (y) {
/* jshint bitwise: false */
return x * y | 0;
};
};
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Semiring"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_Row = PS["Type.Data.Row"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Semiring = function (add, mul, one, zero) {
this.add = add;
this.mul = mul;
this.one = one;
this.zero = zero;
};
var zero = function (dict) {
return dict.zero;
};
var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
var one = function (dict) {
return dict.one;
};
var mul = function (dict) {
return dict.mul;
};
var add = function (dict) {
return dict.add;
};
exports["Semiring"] = Semiring;
exports["add"] = add;
exports["zero"] = zero;
exports["mul"] = mul;
exports["one"] = one;
exports["semiringInt"] = semiringInt;
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Ring"];
var Data_Semiring = PS["Data.Semiring"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Ring = function (Semiring0, sub) {
this.Semiring0 = Semiring0;
this.sub = sub;
};
var sub = function (dict) {
return dict.sub;
};
var ringInt = new Ring(function () {
return Data_Semiring.semiringInt;
}, $foreign.intSub);
exports["Ring"] = Ring;
exports["sub"] = sub;
exports["ringInt"] = ringInt;
})(PS["Data.Ring"] = PS["Data.Ring"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Ord"];
var Data_Eq = PS["Data.Eq"];
var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Ring = PS["Data.Ring"];
var Data_Semiring = PS["Data.Semiring"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Data_Void = PS["Data.Void"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Ord = function (Eq0, compare) {
this.Eq0 = Eq0;
this.compare = compare;
};
var ordInt = new Ord(function () {
return Data_Eq.eqInt;
}, Data_Ord_Unsafe.unsafeCompare);
var ordChar = new Ord(function () {
return Data_Eq.eqChar;
}, Data_Ord_Unsafe.unsafeCompare);
var compare = function (dict) {
return dict.compare;
};
exports["Ord"] = Ord;
exports["compare"] = compare;
exports["ordInt"] = ordInt;
exports["ordChar"] = ordChar;
})(PS["Data.Ord"] = PS["Data.Ord"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Category = PS["Control.Category"];
var Data_Boolean = PS["Data.Boolean"];
var Data_Ord = PS["Data.Ord"];
var Data_Ring = PS["Data.Ring"];
var flip = function (f) {
return function (b) {
return function (a) {
return f(a)(b);
};
};
};
var $$const = function (a) {
return function (v) {
return a;
};
};
exports["flip"] = flip;
exports["const"] = $$const;
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
"use strict";
exports.arrayMap = function (f) {
return function (arr) {
var l = arr.length;
var result = new Array(l);
for (var i = 0; i < l; i++) {
result[i] = f(arr[i]);
}
return result;
};
};
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Functor"];
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Data_Function = PS["Data.Function"];
var Data_Unit = PS["Data.Unit"];
var Functor = function (map) {
this.map = map;
};
var map = function (dict) {
return dict.map;
};
var functorArray = new Functor($foreign.arrayMap);
exports["Functor"] = Functor;
exports["map"] = map;
exports["functorArray"] = functorArray;
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Control.Apply"];
var Control_Category = PS["Control.Category"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Apply = function (Functor0, apply) {
this.Functor0 = Functor0;
this.apply = apply;
};
var applyArray = new Apply(function () {
return Data_Functor.functorArray;
}, $foreign.arrayApply);
var apply = function (dict) {
return dict.apply;
};
var applySecond = function (dictApply) {
return function (a) {
return function (b) {
return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn)))(a))(b);
};
};
};
exports["Apply"] = Apply;
exports["apply"] = apply;
exports["applySecond"] = applySecond;
exports["applyArray"] = applyArray;
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Apply = PS["Control.Apply"];
var Data_Functor = PS["Data.Functor"];
var Data_Unit = PS["Data.Unit"];
var Applicative = function (Apply0, pure) {
this.Apply0 = Apply0;
this.pure = pure;
};
var pure = function (dict) {
return dict.pure;
};
var liftA1 = function (dictApplicative) {
return function (f) {
return function (a) {
return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
};
};
};
exports["Applicative"] = Applicative;
exports["pure"] = pure;
exports["liftA1"] = liftA1;
})(PS["Control.Applicative"] = PS["Control.Applicative"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Control.Bind"];
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Category = PS["Control.Category"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Data_Unit = PS["Data.Unit"];
var Bind = function (Apply0, bind) {
this.Apply0 = Apply0;
this.bind = bind;
};
var Discard = function (discard) {
this.discard = discard;
};
var discard = function (dict) {
return dict.discard;
};
var bindArray = new Bind(function () {
return Control_Apply.applyArray;
}, $foreign.arrayBind);
var bind = function (dict) {
return dict.bind;
};
var discardUnit = new Discard(function (dictBind) {
return bind(dictBind);
});
var join = function (dictBind) {
return function (m) {
return bind(dictBind)(m)(Control_Category.identity(Control_Category.categoryFn));
};
};
exports["Bind"] = Bind;
exports["bind"] = bind;
exports["Discard"] = Discard;
exports["discard"] = discard;
exports["join"] = join;
exports["bindArray"] = bindArray;
exports["discardUnit"] = discardUnit;
})(PS["Control.Bind"] = PS["Control.Bind"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Bind = PS["Control.Bind"];
var Data_Functor = PS["Data.Functor"];
var Data_Unit = PS["Data.Unit"];
var Monad = function (Applicative0, Bind1) {
this.Applicative0 = Applicative0;
this.Bind1 = Bind1;
};
var ap = function (dictMonad) {
return function (f) {
return function (a) {
return Control_Bind.bind(dictMonad.Bind1())(f)(function (v) {
return Control_Bind.bind(dictMonad.Bind1())(a)(function (v1) {
return Control_Applicative.pure(dictMonad.Applicative0())(v(v1));
});
});
};
};
};
exports["Monad"] = Monad;
exports["ap"] = ap;
})(PS["Control.Monad"] = PS["Control.Monad"] || {});
(function(exports) {
"use strict";
exports.topInt = 2147483647;
exports.bottomInt = -2147483648;
exports.topChar = String.fromCharCode(65535);
exports.bottomChar = String.fromCharCode(0);
})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Bounded"];
var Data_Ord = PS["Data.Ord"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Unit = PS["Data.Unit"];
var Bounded = function (Ord0, bottom, top) {
this.Ord0 = Ord0;
this.bottom = bottom;
this.top = top;
};
var top = function (dict) {
return dict.top;
};
var boundedInt = new Bounded(function () {
return Data_Ord.ordInt;
}, $foreign.bottomInt, $foreign.topInt);
var boundedChar = new Bounded(function () {
return Data_Ord.ordChar;
}, $foreign.bottomChar, $foreign.topChar);
var bottom = function (dict) {
return dict.bottom;
};
exports["Bounded"] = Bounded;
exports["bottom"] = bottom;
exports["top"] = top;
exports["boundedInt"] = boundedInt;
exports["boundedChar"] = boundedChar;
})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
(function(exports) {
"use strict";
exports.intDegree = function (x) {
return Math.min(Math.abs(x), 2147483647);
};
// See the Euclidean definition in
// https://en.m.wikipedia.org/wiki/Modulo_operation.
exports.intDiv = function (x) {
return function (y) {
if (y === 0) return 0;
return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
};
};
exports.intMod = function (x) {
return function (y) {
if (y === 0) return 0;
var yy = Math.abs(y);
return ((x % yy) + yy) % yy;
};
};
})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Data_Ring = PS["Data.Ring"];
var Data_Semiring = PS["Data.Semiring"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var CommutativeRing = function (Ring0) {
this.Ring0 = Ring0;
};
var commutativeRingInt = new CommutativeRing(function () {
return Data_Ring.ringInt;
});
exports["CommutativeRing"] = CommutativeRing;
exports["commutativeRingInt"] = commutativeRingInt;
})(PS["Data.CommutativeRing"] = PS["Data.CommutativeRing"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.EuclideanRing"];
var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
var Data_CommutativeRing = PS["Data.CommutativeRing"];
var Data_Eq = PS["Data.Eq"];
var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
var Data_Ring = PS["Data.Ring"];
var Data_Semiring = PS["Data.Semiring"];
var EuclideanRing = function (CommutativeRing0, degree, div, mod) {
this.CommutativeRing0 = CommutativeRing0;
this.degree = degree;
this.div = div;
this.mod = mod;
};
var mod = function (dict) {
return dict.mod;
};
var euclideanRingInt = new EuclideanRing(function () {
return Data_CommutativeRing.commutativeRingInt;
}, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);
var div = function (dict) {
return dict.div;
};
var degree = function (dict) {
return dict.degree;
};
exports["EuclideanRing"] = EuclideanRing;
exports["degree"] = degree;
exports["div"] = div;
exports["mod"] = mod;
exports["euclideanRingInt"] = euclideanRingInt;
})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Data_Boolean = PS["Data.Boolean"];
var Data_Eq = PS["Data.Eq"];
var Data_EuclideanRing = PS["Data.EuclideanRing"];
var Data_Ord = PS["Data.Ord"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Symbol = PS["Data.Symbol"];
var Data_Unit = PS["Data.Unit"];
var Record_Unsafe = PS["Record.Unsafe"];
var Type_Data_RowList = PS["Type.Data.RowList"];
var Monoid = function (Semigroup0, mempty) {
this.Semigroup0 = Semigroup0;
this.mempty = mempty;
};
var monoidString = new Monoid(function () {
return Data_Semigroup.semigroupString;
}, "");
var mempty = function (dict) {
return dict.mempty;
};
exports["Monoid"] = Monoid;
exports["mempty"] = mempty;
exports["monoidString"] = monoidString;
})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Alt = PS["Control.Alt"];
var Control_Alternative = PS["Control.Alternative"];
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Bind = PS["Control.Bind"];
var Control_Category = PS["Control.Category"];
var Control_Extend = PS["Control.Extend"];
var Control_Monad = PS["Control.Monad"];
var Control_MonadZero = PS["Control.MonadZero"];
var Control_Plus = PS["Control.Plus"];
var Data_Bounded = PS["Data.Bounded"];
var Data_Eq = PS["Data.Eq"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
var Data_Monoid = PS["Data.Monoid"];
var Data_Ord = PS["Data.Ord"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Show = PS["Data.Show"];
var Data_Unit = PS["Data.Unit"];
var Prelude = PS["Prelude"];
var Nothing = (function () {
function Nothing() {
};
Nothing.value = new Nothing();
return Nothing;
})();
var Just = (function () {
function Just(value0) {
this.value0 = value0;
};
Just.create = function (value0) {
return new Just(value0);
};
return Just;
})();
var maybe = function (v) {
return function (v1) {
return function (v2) {
if (v2 instanceof Nothing) {
return v;
};
if (v2 instanceof Just) {
return v1(v2.value0);
};
throw new Error("Failed pattern match at Data.Maybe (line 217, column 1 - line 217, column 51): " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
};
};
};
var isNothing = maybe(true)(Data_Function["const"](false));
var functorMaybe = new Data_Functor.Functor(function (v) {
return function (v1) {
if (v1 instanceof Just) {
return new Just(v(v1.value0));
};
return Nothing.value;
};
});
var fromMaybe = function (a) {
return maybe(a)(Control_Category.identity(Control_Category.categoryFn));
};
var fromJust = function (dictPartial) {
return function (v) {
if (v instanceof Just) {
return v.value0;
};
throw new Error("Failed pattern match at Data.Maybe (line 268, column 1 - line 268, column 46): " + [ v.constructor.name ]);
};
};
var eqMaybe = function (dictEq) {
return new Data_Eq.Eq(function (x) {
return function (y) {
if (x instanceof Nothing && y instanceof Nothing) {
return true;
};
if (x instanceof Just && y instanceof Just) {
return Data_Eq.eq(dictEq)(x.value0)(y.value0);
};
return false;
};
});
};
var applyMaybe = new Control_Apply.Apply(function () {
return functorMaybe;
}, function (v) {
return function (v1) {
if (v instanceof Just) {
return Data_Functor.map(functorMaybe)(v.value0)(v1);
};
if (v instanceof Nothing) {
return Nothing.value;
};
throw new Error("Failed pattern match at Data.Maybe (line 67, column 1 - line 67, column 35): " + [ v.constructor.name, v1.constructor.name ]);
};
});
var bindMaybe = new Control_Bind.Bind(function () {
return applyMaybe;
}, function (v) {
return function (v1) {
if (v instanceof Just) {
return v1(v.value0);
};
if (v instanceof Nothing) {
return Nothing.value;
};
throw new Error("Failed pattern match at Data.Maybe (line 125, column 1 - line 125, column 33): " + [ v.constructor.name, v1.constructor.name ]);
};
});
var applicativeMaybe = new Control_Applicative.Applicative(function () {
return applyMaybe;
}, Just.create);
exports["Nothing"] = Nothing;
exports["Just"] = Just;
exports["maybe"] = maybe;
exports["fromMaybe"] = fromMaybe;
exports["isNothing"] = isNothing;
exports["fromJust"] = fromJust;
exports["functorMaybe"] = functorMaybe;
exports["applyMaybe"] = applyMaybe;
exports["applicativeMaybe"] = applicativeMaybe;
exports["bindMaybe"] = bindMaybe;
exports["eqMaybe"] = eqMaybe;
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(function(exports) {
"use strict";
/* global Symbol */
var hasArrayFrom = typeof Array.from === "function";
var hasStringIterator =
typeof Symbol !== "undefined" &&
Symbol != null &&
typeof Symbol.iterator !== "undefined" &&
typeof String.prototype[Symbol.iterator] === "function";
var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
var hasCodePointAt = typeof String.prototype.codePointAt === "function";
exports._unsafeCodePointAt0 = function (fallback) {
return hasCodePointAt
? function (str) { return str.codePointAt(0); }
: fallback;
};
exports._singleton = function (fallback) {
return hasFromCodePoint ? String.fromCodePoint : fallback;
};
exports._take = function (fallback) {
return function (n) {
if (hasStringIterator) {
return function (str) {
var accum = "";
var iter = str[Symbol.iterator]();
for (var i = 0; i < n; ++i) {
var o = iter.next();
if (o.done) return accum;
accum += o.value;
}
return accum;
};
}
return fallback(n);
};
};
exports._toCodePointArray = function (fallback) {
return function (unsafeCodePointAt0) {
if (hasArrayFrom) {
return function (str) {
return Array.from(str, unsafeCodePointAt0);
};
}
return fallback;
};
};
})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
(function(exports) {
"use strict";
exports.fromFoldableImpl = (function () {
function Cons(head, tail) {
this.head = head;
this.tail = tail;
}
var emptyList = {};
function curryCons(head) {
return function (tail) {
return new Cons(head, tail);
};
}
function listToArray(list) {
var result = [];
var count = 0;
var xs = list;
while (xs !== emptyList) {
result[count++] = xs.head;
xs = xs.tail;
}
return result;
}
return function (foldr) {
return function (xs) {
return listToArray(foldr(curryCons)(emptyList)(xs));
};
};
})();
//------------------------------------------------------------------------------
// Array size ------------------------------------------------------------------
//------------------------------------------------------------------------------
exports.length = function (xs) {
return xs.length;
};
exports.snoc = function (l) {
return function (e) {
var l1 = l.slice();
l1.push(e);
return l1;
};
};
//------------------------------------------------------------------------------
// Indexed operations ----------------------------------------------------------
//------------------------------------------------------------------------------
exports.indexImpl = function (just) {
return function (nothing) {
return function (xs) {
return function (i) {
return i < 0 || i >= xs.length ? nothing : just(xs[i]);
};
};
};
};
exports.concat = function (xss) {
if (xss.length <= 10000) {
// This method is faster, but it crashes on big arrays.
// So we use it when can and fallback to simple variant otherwise.
return Array.prototype.concat.apply([], xss);
}
var result = [];
for (var i = 0, l = xss.length; i < l; i++) {
var xs = xss[i];
for (var j = 0, m = xs.length; j < m; j++) {
result.push(xs[j]);
}
}
return result;
};
exports.filter = function (f) {
return function (xs) {
return xs.filter(f);
};
};
//------------------------------------------------------------------------------
// Subarrays -------------------------------------------------------------------
//------------------------------------------------------------------------------
exports.slice = function (s) {
return function (e) {
return function (l) {
return l.slice(s, e);
};
};
};
exports.take = function (n) {
return function (l) {
return n < 1 ? [] : l.slice(0, n);
};
};
exports.drop = function (n) {
return function (l) {
return n < 1 ? l : l.slice(n);
};
};
//------------------------------------------------------------------------------
// Zipping ---------------------------------------------------------------------
//------------------------------------------------------------------------------
exports.zipWith = function (f) {
return function (xs) {
return function (ys) {
var l = xs.length < ys.length ? xs.length : ys.length;
var result = new Array(l);
for (var i = 0; i < l; i++) {
result[i] = f(xs[i])(ys[i]);
}
return result;
};
};
};
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
"use strict";
exports.map_ = function (f) {
return function (a) {
return function () {
return f(a());
};
};
};
exports.pure_ = function (a) {
return function () {
return a;
};
};
exports.bind_ = function (a) {
return function (f) {
return function () {
return f(a())();
};
};
};
})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Control.Monad.ST.Internal"];
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Bind = PS["Control.Bind"];
var Control_Monad = PS["Control.Monad"];
var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
var Data_Functor = PS["Data.Functor"];
var Data_Unit = PS["Data.Unit"];
var Partial_Unsafe = PS["Partial.Unsafe"];
var Prelude = PS["Prelude"];
var functorST = new Data_Functor.Functor($foreign.map_);
var monadST = new Control_Monad.Monad(function () {
return applicativeST;
}, function () {
return bindST;
});
var bindST = new Control_Bind.Bind(function () {
return applyST;
}, $foreign.bind_);
var applyST = new Control_Apply.Apply(function () {
return functorST;
}, Control_Monad.ap(monadST));
var applicativeST = new Control_Applicative.Applicative(function () {
return applyST;
}, $foreign.pure_);
exports["functorST"] = functorST;
exports["applyST"] = applyST;
exports["applicativeST"] = applicativeST;
exports["bindST"] = bindST;
exports["monadST"] = monadST;
})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
(function(exports) {
"use strict";
exports.foldrArray = function (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;
};
};
};
exports.foldlArray = function (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;
};
};
};
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Bind = PS["Control.Bind"];
var Control_Monad = PS["Control.Monad"];
var Data_Bounded = PS["Data.Bounded"];
var Data_Eq = PS["Data.Eq"];
var Data_Functor = PS["Data.Functor"];
var Data_Monoid = PS["Data.Monoid"];
var Data_Ord = PS["Data.Ord"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Show = PS["Data.Show"];
var Prelude = PS["Prelude"];
var Dual = function (x) {
return x;
};
var semigroupDual = function (dictSemigroup) {
return new Data_Semigroup.Semigroup(function (v) {
return function (v1) {
return Data_Semigroup.append(dictSemigroup)(v1)(v);
};
});
};
var monoidDual = function (dictMonoid) {
return new Data_Monoid.Monoid(function () {
return semigroupDual(dictMonoid.Semigroup0());
}, Data_Monoid.mempty(dictMonoid));
};
exports["Dual"] = Dual;
exports["semigroupDual"] = semigroupDual;
exports["monoidDual"] = monoidDual;
})(PS["Data.Monoid.Dual"] = PS["Data.Monoid.Dual"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Category = PS["Control.Category"];
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Data_Bounded = PS["Data.Bounded"];
var Data_Eq = PS["Data.Eq"];
var Data_Monoid = PS["Data.Monoid"];
var Data_Ord = PS["Data.Ord"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Show = PS["Data.Show"];
var Prelude = PS["Prelude"];
var Endo = function (x) {
return x;
};
var semigroupEndo = function (dictSemigroupoid) {
return new Data_Semigroup.Semigroup(function (v) {
return function (v1) {
return Control_Semigroupoid.compose(dictSemigroupoid)(v)(v1);
};
});
};
var monoidEndo = function (dictCategory) {
return new Data_Monoid.Monoid(function () {
return semigroupEndo(dictCategory.Semigroupoid0());
}, Control_Category.identity(dictCategory));
};
exports["Endo"] = Endo;
exports["semigroupEndo"] = semigroupEndo;
exports["monoidEndo"] = monoidEndo;
})(PS["Data.Monoid.Endo"] = PS["Data.Monoid.Endo"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
var Data_Semigroup_First = PS["Data.Semigroup.First"];
var Data_Semigroup_Last = PS["Data.Semigroup.Last"];
var Prelude = PS["Prelude"];
var Newtype = function (unwrap, wrap) {
this.unwrap = unwrap;
this.wrap = wrap;
};
var wrap = function (dict) {
return dict.wrap;
};
var unwrap = function (dict) {
return dict.unwrap;
};
var newtypeEndo = new Newtype(function (v) {
return v;
}, Data_Monoid_Endo.Endo);
var newtypeDual = new Newtype(function (v) {
return v;
}, Data_Monoid_Dual.Dual);
exports["unwrap"] = unwrap;
exports["wrap"] = wrap;
exports["Newtype"] = Newtype;
exports["newtypeDual"] = newtypeDual;
exports["newtypeEndo"] = newtypeEndo;
})(PS["Data.Newtype"] = PS["Data.Newtype"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Foldable"];
var Control_Alt = PS["Control.Alt"];
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Bind = PS["Control.Bind"];
var Control_Category = PS["Control.Category"];
var Control_Plus = PS["Control.Plus"];
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Data_Eq = PS["Data.Eq"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
var Data_Maybe = PS["Data.Maybe"];
var Data_Maybe_First = PS["Data.Maybe.First"];
var Data_Maybe_Last = PS["Data.Maybe.Last"];
var Data_Monoid = PS["Data.Monoid"];
var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
var Data_Newtype = PS["Data.Newtype"];
var Data_Ord = PS["Data.Ord"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Semiring = PS["Data.Semiring"];
var Data_Unit = PS["Data.Unit"];
var Prelude = PS["Prelude"];
var Foldable = function (foldMap, foldl, foldr) {
this.foldMap = foldMap;
this.foldl = foldl;
this.foldr = foldr;
};
var foldr = function (dict) {
return dict.foldr;
};
var traverse_ = function (dictApplicative) {
return function (dictFoldable) {
return function (f) {
return foldr(dictFoldable)(function ($195) {
return Control_Apply.applySecond(dictApplicative.Apply0())(f($195));
})(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
};
};
};
var for_ = function (dictApplicative) {
return function (dictFoldable) {
return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
};
};
var foldl = function (dict) {
return dict.foldl;
};
var intercalate = function (dictFoldable) {
return function (dictMonoid) {
return function (sep) {
return function (xs) {
var go = function (v) {
return function (x) {
if (v.init) {
return {
init: false,
acc: x
};
};
return {
init: false,
acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
};
};
};
return (foldl(dictFoldable)(go)({
init: true,
acc: Data_Monoid.mempty(dictMonoid)
})(xs)).acc;
};
};
};
};
var foldMapDefaultR = function (dictFoldable) {
return function (dictMonoid) {
return function (f) {
return foldr(dictFoldable)(function (x) {
return function (acc) {
return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
};
})(Data_Monoid.mempty(dictMonoid));
};
};
};
var foldableArray = new Foldable(function (dictMonoid) {
return foldMapDefaultR(foldableArray)(dictMonoid);
}, $foreign.foldlArray, $foreign.foldrArray);
var foldMap = function (dict) {
return dict.foldMap;
};
var foldlDefault = function (dictFoldable) {
return function (c) {
return function (u) {
return function (xs) {
return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(Data_Newtype.unwrap(Data_Newtype.newtypeDual)(foldMap(dictFoldable)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn)))(function ($197) {
return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(c)($197)));
})(xs)))(u);
};
};
};
};
var foldM = function (dictFoldable) {
return function (dictMonad) {
return function (f) {
return function (a0) {
return foldl(dictFoldable)(function (ma) {
return function (b) {
return Control_Bind.bind(dictMonad.Bind1())(ma)(Data_Function.flip(f)(b));
};
})(Control_Applicative.pure(dictMonad.Applicative0())(a0));
};
};
};
};
var fold = function (dictFoldable) {
return function (dictMonoid) {
return foldMap(dictFoldable)(dictMonoid)(Control_Category.identity(Control_Category.categoryFn));
};
};
var find = function (dictFoldable) {
return function (p) {
var go = function (v) {
return function (v1) {
if (v instanceof Data_Maybe.Nothing && p(v1)) {
return new Data_Maybe.Just(v1);
};
return v;
};
};
return foldl(dictFoldable)(go)(Data_Maybe.Nothing.value);
};
};
exports["Foldable"] = Foldable;
exports["foldr"] = foldr;
exports["foldl"] = foldl;
exports["foldMap"] = foldMap;
exports["foldlDefault"] = foldlDefault;
exports["foldMapDefaultR"] = foldMapDefaultR;
exports["fold"] = fold;
exports["foldM"] = foldM;
exports["traverse_"] = traverse_;
exports["for_"] = for_;
exports["intercalate"] = intercalate;
exports["find"] = find;
exports["foldableArray"] = foldableArray;
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
"use strict";
// jshint maxparams: 3
exports.traverseArrayImpl = function () {
function array1(a) {
return [a];
}
function array2(a) {
return function (b) {
return [a, b];
};
}
function array3(a) {
return function (b) {
return function (c) {
return [a, b, c];
};
};
}
function concat2(xs) {
return function (ys) {
return xs.concat(ys);
};
}
return function (apply) {
return function (map) {
return function (pure) {
return function (f) {
return function (array) {
function go(bot, top) {
switch (top - bot) {
case 0: return pure([]);
case 1: return map(array1)(f(array[bot]));
case 2: return apply(map(array2)(f(array[bot])))(f(array[bot + 1]));
case 3: return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
default:
// This slightly tricky pivot selection aims to produce two
// even-length partitions where possible.
var pivot = bot + Math.floor((top - bot) / 4) * 2;
return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
}
}
return go(0, array.length);
};
};
};
};
};
}();
})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var $foreign = PS["Data.Traversable"];
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Category = PS["Control.Category"];
var Data_Foldable = PS["Data.Foldable"];
var Data_Functor = PS["Data.Functor"];
var Data_Maybe = PS["Data.Maybe"];
var Data_Maybe_First = PS["Data.Maybe.First"];
var Data_Maybe_Last = PS["Data.Maybe.Last"];
var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
var Prelude = PS["Prelude"];
var Traversable = function (Foldable1, Functor0, sequence, traverse) {
this.Foldable1 = Foldable1;
this.Functor0 = Functor0;
this.sequence = sequence;
this.traverse = traverse;
};
var traverse = function (dict) {
return dict.traverse;
};
var sequenceDefault = function (dictTraversable) {
return function (dictApplicative) {
return traverse(dictTraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
};
};
var traversableArray = new Traversable(function () {
return Data_Foldable.foldableArray;
}, function () {
return Data_Functor.functorArray;
}, function (dictApplicative) {
return sequenceDefault(traversableArray)(dictApplicative);
}, function (dictApplicative) {
return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
});
var sequence = function (dict) {
return dict.sequence;
};
exports["Traversable"] = Traversable;
exports["traverse"] = traverse;
exports["sequence"] = sequence;
exports["sequenceDefault"] = sequenceDefault;
exports["traversableArray"] = traversableArray;
})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
(function(exports) {
// Generated by purs version 0.12.3
"use strict";
var Control_Applicative = PS["Control.Applicative"];
var Control_Apply = PS["Control.Apply"];
var Control_Biapplicative = PS["Control.Biapplicative"];
var Control_Biapply = PS["Control.Biapply"];
var Control_Bind = PS["Control.Bind"];
var Control_Comonad = PS["Control.Comonad"];
var Control_Extend = PS["Control.Extend"];
var Control_Lazy = PS["Control.Lazy"];
var Control_Monad = PS["Control.Monad"];
var Control_Semigroupoid = PS["Control.Semigroupoid"];
var Data_Bifoldable = PS["Data.Bifoldable"];
var Data_Bifunctor = PS["Data.Bifunctor"];
var Data_Bitraversable = PS["Data.Bitraversable"];
var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
var Data_Bounded = PS["Data.Bounded"];
var Data_CommutativeRing = PS["Data.CommutativeRing"];
var Data_Distributive = PS["Data.Distributive"];
var Data_Eq = PS["Data.Eq"];
var Data_Foldable = PS["Data.Foldable"];
var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
var Data_Function = PS["Data.Function"];
var Data_Functor = PS["Data.Functor"];
var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
var Data_Maybe = PS["Data.Maybe"];
var Data_Maybe_First = PS["Data.Maybe.First"];
var Data_Monoid = PS["Data.Monoid"];
var Data_Newtype = PS["Data.Newtype"];
var Data_Ord = PS["Data.Ord"];
var Data_Ordering = PS["Data.Ordering"];
var Data_Ring = PS["Data.Ring"];
var Data_Semigroup = PS["Data.Semigroup"];
var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
var Data_Semiring = PS["Data.Semiring"];
var Data_Show = PS["Data.Show"];
var Data_Traversable = PS["Data.Traversable"];
var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
var Data_Unit = PS["Data.Unit"];
var Prelude = PS["Prelude"];
var Type_Equality = PS["Type.Equality"];
var Tuple = (function () {
function Tuple(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
Tuple.create = function (value0) {
return function (value1) {
return new Tuple(value0, value1);
};
};
return Tuple;
})();
var snd = function (v) {
return v.value1;
};
var fst = function (v) {
return v.value0;
};
expor