diff --git a/.gitignore b/.gitignore index 6aa865b..1dd11f9 100644 --- a/.gitignore +++ b/.gitignore @@ -25,5 +25,3 @@ lib/bs .merlin .bsb.lock /node_modules/ -*.bs.js -*.mjs \ No newline at end of file diff --git a/package.json b/package.json index 86d6cdc..4250409 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,6 @@ "author": "bloodyowl ", "license": "MIT", "devDependencies": { - "rescript": "^10.1.0-rc.2" + "rescript": "file:../rescript-compiler" } } diff --git a/src/OCamlCompat.mjs b/src/OCamlCompat.mjs new file mode 100644 index 0000000..f7b93b8 --- /dev/null +++ b/src/OCamlCompat.mjs @@ -0,0 +1,21 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var $$Array; + +var List; + +var $$Set; + +var $$Map; + +var $$String; + +export { + $$Array , + List , + $$Set , + $$Map , + $$String , +} +/* No side effect */ diff --git a/src/OCamlCompat.res b/src/OCamlCompat.res index e20123a..8caf67f 100644 --- a/src/OCamlCompat.res +++ b/src/OCamlCompat.res @@ -1,3 +1,4 @@ +@@uncurried module Array = Array module List = List module Set = Set diff --git a/src/ReScriptStdLib.mjs b/src/ReScriptStdLib.mjs new file mode 100644 index 0000000..12b3551 --- /dev/null +++ b/src/ReScriptStdLib.mjs @@ -0,0 +1,156 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var $$Array; + +var Console; + +var $$DataView; + +var $$Date; + +var Dict; + +var $$Error; + +var Float; + +var Global; + +var Int; + +var $$BigInt; + +var $$Math; + +var Null; + +var Nullable; + +var $$Object; + +var $$Promise; + +var $$RegExp; + +var $$String; + +var Undefined; + +var $$Symbol; + +var Type; + +var $$JSON; + +var Iterator; + +var AsyncIterator; + +var $$Map; + +var $$WeakMap; + +var $$Set; + +var $$WeakSet; + +var $$ArrayBuffer; + +var TypedArray; + +var $$Float32Array; + +var $$Float64Array; + +var $$Int8Array; + +var $$Int16Array; + +var $$Int32Array; + +var $$Uint8Array; + +var $$Uint16Array; + +var $$Uint32Array; + +var $$Uint8ClampedArray; + +var $$BigInt64Array; + +var $$BigUint64Array; + +var $$Intl; + +var Serializer; + +var Fn; + +var MapperRt; + +var Internal; + +var Re; + +var Exn; + +var $$Option; + +var List; + +var Result; + +export { + $$Array , + Console , + $$DataView , + $$Date , + Dict , + $$Error , + Float , + Global , + Int , + $$BigInt , + $$Math , + Null , + Nullable , + $$Object , + $$Promise , + $$RegExp , + $$String , + Undefined , + $$Symbol , + Type , + $$JSON , + Iterator , + AsyncIterator , + $$Map , + $$WeakMap , + $$Set , + $$WeakSet , + $$ArrayBuffer , + TypedArray , + $$Float32Array , + $$Float64Array , + $$Int8Array , + $$Int16Array , + $$Int32Array , + $$Uint8Array , + $$Uint16Array , + $$Uint32Array , + $$Uint8ClampedArray , + $$BigInt64Array , + $$BigUint64Array , + $$Intl , + Serializer , + Fn , + MapperRt , + Internal , + Re , + Exn , + $$Option , + List , + Result , +} +/* No side effect */ diff --git a/src/ReScriptStdLib.res b/src/ReScriptStdLib.res index 5f32a2c..2823374 100644 --- a/src/ReScriptStdLib.res +++ b/src/ReScriptStdLib.res @@ -1,3 +1,4 @@ +@@uncurried module Array = Stdlib__Array module Console = Stdlib__Console module DataView = Stdlib__DataView diff --git a/src/Stdlib__Array.mjs b/src/Stdlib__Array.mjs new file mode 100644 index 0000000..b1e5256 --- /dev/null +++ b/src/Stdlib__Array.mjs @@ -0,0 +1,129 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Js_math from "rescript/lib/es6/js_math.js"; +import * as Caml_option from "rescript/lib/es6/caml_option.js"; +import * as Caml_splice_call from "rescript/lib/es6/caml_splice_call.js"; + +function indexOfOpt(arr, item) { + var index = arr.indexOf(item); + if (index !== -1) { + return index; + } + +} + +function lastIndexOfOpt(arr, item) { + var index = arr.lastIndexOf(item); + if (index !== -1) { + return index; + } + +} + +function reduce(a, x, f) { + var f$1 = function (a, b) { + return f(a, b); + }; + var r = x; + for(var i = 0 ,i_finish = a.length; i < i_finish; ++i){ + r = f$1(r, a[i]); + } + return r; +} + +function reduceWithIndex(a, x, f) { + var f$1 = function (a, b, c) { + return f(a, b, c); + }; + var r = x; + for(var i = 0 ,i_finish = a.length; i < i_finish; ++i){ + r = f$1(r, a[i], i); + } + return r; +} + +function reduceReverse(a, x, f) { + var f$1 = function (a, b) { + return f(a, b); + }; + var r = x; + for(var i = a.length - 1 | 0; i >= 0; --i){ + r = f$1(r, a[i]); + } + return r; +} + +function findIndexOpt(array, finder) { + var index = array.findIndex(finder); + if (index !== -1) { + return index; + } + +} + +function swapUnsafe(xs, i, j) { + var tmp = xs[i]; + xs[i] = xs[j]; + xs[j] = tmp; +} + +function reverse(xs) { + var len = xs.length; + var result = new Array(len); + for(var i = 0; i < len; ++i){ + result[i] = xs[(len - 1 | 0) - i | 0]; + } + return result; +} + +function shuffleInPlace(xs) { + var len = xs.length; + for(var i = 0; i < len; ++i){ + swapUnsafe(xs, i, Js_math.random_int(i, len)); + } +} + +function shuffle(xs) { + var result = xs.slice(); + shuffleInPlace(result); + return result; +} + +function filterMap(a, f) { + var f$1 = function (a) { + return f(a); + }; + var l = a.length; + var r = new Array(l); + var j = 0; + for(var i = 0; i < l; ++i){ + var v = a[i]; + var v$1 = f$1(v); + if (v$1 !== undefined) { + r[j] = Caml_option.valFromOption(v$1); + j = j + 1 | 0; + } + + } + r.length = j; + return r; +} + +function flatMap(a, f) { + return Caml_splice_call.spliceObjApply([], "concat", [a.map(f)]); +} + +export { + indexOfOpt , + lastIndexOfOpt , + reduce , + reduceReverse , + reduceWithIndex , + findIndexOpt , + reverse , + filterMap , + shuffle , + shuffleInPlace , + flatMap , +} +/* No side effect */ diff --git a/src/Stdlib__Array.res b/src/Stdlib__Array.res index 8839499..fe5bc9a 100644 --- a/src/Stdlib__Array.res +++ b/src/Stdlib__Array.res @@ -1,3 +1,4 @@ +@@uncurried external getUnsafe: (array<'a>, int) => 'a = "%array_unsafe_get" external setUnsafe: (array<'a>, int, 'a) => unit = "%array_unsafe_set" @@ -99,34 +100,34 @@ let lastIndexOfOpt = (arr, item) => @send external mapWithIndex: (array<'a>, ('a, int) => 'b) => array<'b> = "map" let reduceU = (a, x, f) => { - let r = ref(x) + let r = ref(. x) for i in 0 to length(a) - 1 { - r.contents = f(. r.contents, getUnsafe(a, i)) + r.contents = f(r.contents, getUnsafe(a, i)) } r.contents } -let reduce = (a, x, f) => reduceU(a, x, (. a, b) => f(a, b)) +let reduce = (a, x, f) => reduceU(a, x, (a, b) => f(a, b)) let reduceWithIndexU = (a, x, f) => { - let r = ref(x) + let r = ref(. x) for i in 0 to length(a) - 1 { - r.contents = f(. r.contents, getUnsafe(a, i), i) + r.contents = f(r.contents, getUnsafe(a, i), i) } r.contents } -let reduceWithIndex = (a, x, f) => reduceWithIndexU(a, x, (. a, b, c) => f(a, b, c)) +let reduceWithIndex = (a, x, f) => reduceWithIndexU(a, x, (a, b, c) => f(a, b, c)) let reduceReverseU = (a, x, f) => { - let r = ref(x) + let r = ref(. x) for i in length(a) - 1 downto 0 { - r.contents = f(. r.contents, getUnsafe(a, i)) + r.contents = f(r.contents, getUnsafe(a, i)) } r.contents } -let reduceReverse = (a, x, f) => reduceReverseU(a, x, (. a, b) => f(a, b)) +let reduceReverse = (a, x, f) => reduceReverseU(a, x, (a, b) => f(a, b)) @send external some: (array<'a>, 'a => bool) => bool = "some" @send external someWithIndex: (array<'a>, ('a, int) => bool) => bool = "some" @@ -164,7 +165,7 @@ let reverse = xs => { let shuffleInPlace = xs => { let len = length(xs) for i in 0 to len - 1 { - swapUnsafe(xs, i, Js.Math.random_int(i, len)) /* [i,len) */ + swapUnsafe(xs, i, Js.Math.random_int(. i, len)) /* [i,len) */ } } @@ -177,10 +178,10 @@ let shuffle = xs => { let filterMapU = (a, f) => { let l = length(a) let r = makeUninitializedUnsafe(l) - let j = ref(0) + let j = ref(. 0) for i in 0 to l - 1 { let v = getUnsafe(a, i) - switch f(. v) { + switch f(v) { | None => () | Some(v) => setUnsafe(r, j.contents, v) @@ -191,7 +192,7 @@ let filterMapU = (a, f) => { r } -let filterMap = (a, f) => filterMapU(a, (. a) => f(a)) +let filterMap = (a, f) => filterMapU(a, a => f(a)) // TODO: Change this implementation? let flatMap = (a, f) => []->concatMany(map(a, f)) diff --git a/src/Stdlib__Array.resi b/src/Stdlib__Array.resi index fc3b4af..644d706 100644 --- a/src/Stdlib__Array.resi +++ b/src/Stdlib__Array.resi @@ -1,3 +1,4 @@ +@@uncurried @val external from: 'a => array<'b> = "Array.from" @val external fromWithMap: ('a, 'b => 'c) => array<'c> = "Array.from" @val external fromArrayLike: Js.Array2.array_like<'a> => array<'a> = "Array.from" diff --git a/src/Stdlib__ArrayBuffer.mjs b/src/Stdlib__ArrayBuffer.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__ArrayBuffer.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__ArrayBuffer.res b/src/Stdlib__ArrayBuffer.res index 0beb684..2e56305 100644 --- a/src/Stdlib__ArrayBuffer.res +++ b/src/Stdlib__ArrayBuffer.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.TypedArray2.ArrayBuffer.t @new external make: int => t = "ArrayBuffer" diff --git a/src/Stdlib__AsyncIterator.mjs b/src/Stdlib__AsyncIterator.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__AsyncIterator.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__AsyncIterator.res b/src/Stdlib__AsyncIterator.res index f065c06..9f8dfb7 100644 --- a/src/Stdlib__AsyncIterator.res +++ b/src/Stdlib__AsyncIterator.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> type value<'a> = { diff --git a/src/Stdlib__BigInt.mjs b/src/Stdlib__BigInt.mjs new file mode 100644 index 0000000..88c19a2 --- /dev/null +++ b/src/Stdlib__BigInt.mjs @@ -0,0 +1,16 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function toInt(t) { + return Number(t) | 0; +} + +function exp(x, y) { + return (x ** y); +} + +export { + toInt , + exp , +} +/* No side effect */ diff --git a/src/Stdlib__BigInt.res b/src/Stdlib__BigInt.res index 9fc3dd8..e29ac34 100644 --- a/src/Stdlib__BigInt.res +++ b/src/Stdlib__BigInt.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.Types.bigint_val @val external asIntN: (~width: int, t) => t = "BigInt.asIntN" diff --git a/src/Stdlib__Console.mjs b/src/Stdlib__Console.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Console.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Console.res b/src/Stdlib__Console.res index 4f8d710..75356b4 100644 --- a/src/Stdlib__Console.res +++ b/src/Stdlib__Console.res @@ -1,3 +1,4 @@ +@@uncurried @val external log: 'a => unit = "console.log" @val external log2: ('a, 'b) => unit = "console.log" @val external log3: ('a, 'b, 'c) => unit = "console.log" diff --git a/src/Stdlib__DataView.mjs b/src/Stdlib__DataView.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__DataView.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__DataView.res b/src/Stdlib__DataView.res index 51cf530..586a4e5 100644 --- a/src/Stdlib__DataView.res +++ b/src/Stdlib__DataView.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external fromBuffer: Stdlib__ArrayBuffer.t => t = "DataView" diff --git a/src/Stdlib__Date.mjs b/src/Stdlib__Date.mjs new file mode 100644 index 0000000..7df8c7c --- /dev/null +++ b/src/Stdlib__Date.mjs @@ -0,0 +1,12 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Time = {}; + +var UTC = {}; + +export { + Time , + UTC , +} +/* No side effect */ diff --git a/src/Stdlib__Date.res b/src/Stdlib__Date.res index 09b4ee3..d39d4d4 100644 --- a/src/Stdlib__Date.res +++ b/src/Stdlib__Date.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.Date.t module Time = { diff --git a/src/Stdlib__Dict.mjs b/src/Stdlib__Dict.mjs new file mode 100644 index 0000000..8ac967f --- /dev/null +++ b/src/Stdlib__Dict.mjs @@ -0,0 +1,11 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function $$delete$1(dict, string) { + delete(dict[string]); +} + +export { + $$delete$1 as $$delete, +} +/* No side effect */ diff --git a/src/Stdlib__Dict.res b/src/Stdlib__Dict.res index 0d3b881..6871b5c 100644 --- a/src/Stdlib__Dict.res +++ b/src/Stdlib__Dict.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> = Js.Dict.t<'a> @get_index external get: (t<'a>, string) => option<'a> = "" diff --git a/src/Stdlib__Error.mjs b/src/Stdlib__Error.mjs new file mode 100644 index 0000000..b9e0a7a --- /dev/null +++ b/src/Stdlib__Error.mjs @@ -0,0 +1,24 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var $$EvalError = {}; + +var $$RangeError = {}; + +var $$ReferenceError = {}; + +var $$SyntaxError = {}; + +var $$TypeError = {}; + +var $$URIError = {}; + +export { + $$EvalError , + $$RangeError , + $$ReferenceError , + $$SyntaxError , + $$TypeError , + $$URIError , +} +/* No side effect */ diff --git a/src/Stdlib__Error.res b/src/Stdlib__Error.res index 69e0599..97fcf6a 100644 --- a/src/Stdlib__Error.res +++ b/src/Stdlib__Error.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.Exn.t external fromException: exn => option = "?as_js_exn" diff --git a/src/Stdlib__Float.mjs b/src/Stdlib__Float.mjs new file mode 100644 index 0000000..2d9f7f0 --- /dev/null +++ b/src/Stdlib__Float.mjs @@ -0,0 +1,19 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +function fromString(i) { + var i$1 = parseFloat(i); + if (isNaN(i$1)) { + return ; + } else { + return i$1; + } +} + +export { + Constants , + fromString , +} +/* No side effect */ diff --git a/src/Stdlib__Float.res b/src/Stdlib__Float.res index a040f90..f040609 100644 --- a/src/Stdlib__Float.res +++ b/src/Stdlib__Float.res @@ -1,3 +1,4 @@ +@@uncurried module Constants = { @val external nan: float = "NaN" @val external epsilon: float = "Number.EPSILON" diff --git a/src/Stdlib__Float.resi b/src/Stdlib__Float.resi index e47a0b5..faaa37e 100644 --- a/src/Stdlib__Float.resi +++ b/src/Stdlib__Float.resi @@ -1,3 +1,4 @@ +@@uncurried module Constants: { @val external nan: float = "NaN" @val external epsilon: float = "Number.EPSILON" diff --git a/src/Stdlib__Global.mjs b/src/Stdlib__Global.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Global.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Global.res b/src/Stdlib__Global.res index 0edc87b..81f8538 100644 --- a/src/Stdlib__Global.res +++ b/src/Stdlib__Global.res @@ -1,3 +1,4 @@ +@@uncurried type timeoutId = Js.Global.timeoutId @val external setTimeout: (unit => unit, int) => timeoutId = "setTimeout" diff --git a/src/Stdlib__Int.mjs b/src/Stdlib__Int.mjs new file mode 100644 index 0000000..bc8c440 --- /dev/null +++ b/src/Stdlib__Int.mjs @@ -0,0 +1,19 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +function fromString(radix, x) { + var maybeInt = radix !== undefined ? parseInt(x, radix) : parseInt(x); + if (isNaN(maybeInt) || maybeInt > 2147483647 || maybeInt < -2147483648) { + return ; + } else { + return maybeInt | 0; + } +} + +export { + Constants , + fromString , +} +/* No side effect */ diff --git a/src/Stdlib__Int.res b/src/Stdlib__Int.res index e9e52f8..23bcb0d 100644 --- a/src/Stdlib__Int.res +++ b/src/Stdlib__Int.res @@ -1,3 +1,4 @@ +@@uncurried module Constants = { @inline let minValue = -2147483648 @inline let maxValue = 2147483647 diff --git a/src/Stdlib__Intl.mjs b/src/Stdlib__Intl.mjs new file mode 100644 index 0000000..ffed57d --- /dev/null +++ b/src/Stdlib__Intl.mjs @@ -0,0 +1,24 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Collator; + +var DateTimeFormat; + +var Locale; + +var NumberFormat; + +var PluralRules; + +var RelativeTimeFormat; + +export { + Collator , + DateTimeFormat , + Locale , + NumberFormat , + PluralRules , + RelativeTimeFormat , +} +/* No side effect */ diff --git a/src/Stdlib__Intl.res b/src/Stdlib__Intl.res index 7d20258..a436dd1 100644 --- a/src/Stdlib__Intl.res +++ b/src/Stdlib__Intl.res @@ -1,3 +1,4 @@ +@@uncurried module Collator = Stdlib__Intl__Collator module DateTimeFormat = Stdlib__Intl__DateTimeFormat module Locale = Stdlib__Intl__Locale diff --git a/src/Stdlib__Iterator.mjs b/src/Stdlib__Iterator.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Iterator.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Iterator.res b/src/Stdlib__Iterator.res index a13b29a..31e79e1 100644 --- a/src/Stdlib__Iterator.res +++ b/src/Stdlib__Iterator.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> type next<'a> diff --git a/src/Stdlib__JSON.mjs b/src/Stdlib__JSON.mjs new file mode 100644 index 0000000..e6a8e3a --- /dev/null +++ b/src/Stdlib__JSON.mjs @@ -0,0 +1,47 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function classify(value) { + var match = Object.prototype.toString.call(value); + switch (match) { + case "[object Array]" : + return { + TAG: /* Array */4, + _0: value + }; + case "[object Boolean]" : + return { + TAG: /* Bool */0, + _0: value + }; + case "[object Null]" : + return /* Null */0; + case "[object Number]" : + return { + TAG: /* Number */2, + _0: value + }; + case "[object String]" : + return { + TAG: /* String */1, + _0: value + }; + default: + return { + TAG: /* Object */3, + _0: value + }; + } +} + +var Decode = { + classify: classify +}; + +var Encode = {}; + +export { + Decode , + Encode , +} +/* No side effect */ diff --git a/src/Stdlib__JSON.res b/src/Stdlib__JSON.res index 068d737..859867d 100644 --- a/src/Stdlib__JSON.res +++ b/src/Stdlib__JSON.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.Json.t type jsonReviver diff --git a/src/Stdlib__List.mjs b/src/Stdlib__List.mjs new file mode 100644 index 0000000..9790c37 --- /dev/null +++ b/src/Stdlib__List.mjs @@ -0,0 +1,1468 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Belt_Array from "rescript/lib/es6/belt_Array.js"; +import * as Caml_option from "rescript/lib/es6/caml_option.js"; +import * as Stdlib__Array from "./Stdlib__Array.mjs"; +import * as Belt_SortArray from "rescript/lib/es6/belt_SortArray.js"; + +function head(x) { + if (x) { + return Caml_option.some(x.hd); + } + +} + +function headExn(x) { + if (x) { + return x.hd; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; +} + +function tail(x) { + if (x) { + return x.tl; + } + +} + +function tailExn(x) { + if (x) { + return x.tl; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; +} + +function add(xs, x) { + return { + hd: x, + tl: xs + }; +} + +function get(x, n) { + if (n < 0) { + return ; + } else { + var _x = x; + var _n = n; + while(true) { + var n$1 = _n; + var x$1 = _x; + if (!x$1) { + return ; + } + if (n$1 === 0) { + return Caml_option.some(x$1.hd); + } + _n = n$1 - 1 | 0; + _x = x$1.tl; + continue ; + }; + } +} + +function getExn(x, n) { + if (n < 0) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + var _x = x; + var _n = n; + while(true) { + var n$1 = _n; + var x$1 = _x; + if (x$1) { + if (n$1 === 0) { + return x$1.hd; + } + _n = n$1 - 1 | 0; + _x = x$1.tl; + continue ; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + }; +} + +function partitionAux(p, _cell, _precX, _precY) { + while(true) { + var precY = _precY; + var precX = _precX; + var cell = _cell; + if (!cell) { + return ; + } + var t = cell.tl; + var h = cell.hd; + var next = { + hd: h, + tl: /* [] */0 + }; + if (p(h)) { + precX.tl = next; + _precX = next; + _cell = t; + continue ; + } + precY.tl = next; + _precY = next; + _cell = t; + continue ; + }; +} + +function splitAux(_cell, _precX, _precY) { + while(true) { + var precY = _precY; + var precX = _precX; + var cell = _cell; + if (!cell) { + return ; + } + var match = cell.hd; + var nextA = { + hd: match[0], + tl: /* [] */0 + }; + var nextB = { + hd: match[1], + tl: /* [] */0 + }; + precX.tl = nextA; + precY.tl = nextB; + _precY = nextB; + _precX = nextA; + _cell = cell.tl; + continue ; + }; +} + +function copyAuxCont(_cellX, _prec) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return prec; + } + var next = { + hd: cellX.hd, + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + continue ; + }; +} + +function copyAuxWitFilter(f, _cellX, _prec) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return ; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h)) { + var next = { + hd: h, + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue ; + } + _cellX = t; + continue ; + }; +} + +function copyAuxWithFilterIndex(f, _cellX, _prec, _i) { + while(true) { + var i = _i; + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return ; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h, i)) { + var next = { + hd: h, + tl: /* [] */0 + }; + prec.tl = next; + _i = i + 1 | 0; + _prec = next; + _cellX = t; + continue ; + } + _i = i + 1 | 0; + _cellX = t; + continue ; + }; +} + +function copyAuxWitFilterMap(f, _cellX, _prec) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return ; + } + var t = cellX.tl; + var h = f(cellX.hd); + if (h !== undefined) { + var next = { + hd: Caml_option.valFromOption(h), + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue ; + } + _cellX = t; + continue ; + }; +} + +function removeAssocAuxWithMap(_cellX, x, _prec, f) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return false; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h[0], x)) { + prec.tl = t; + return true; + } + var next = { + hd: h, + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue ; + }; +} + +function setAssocAuxWithMap(_cellX, x, k, _prec, eq) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return false; + } + var t = cellX.tl; + var h = cellX.hd; + if (eq(h[0], x)) { + prec.tl = { + hd: [ + x, + k + ], + tl: t + }; + return true; + } + var next = { + hd: h, + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue ; + }; +} + +function copyAuxWithMap(_cellX, _prec, f) { + while(true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return ; + } + var next = { + hd: f(cellX.hd), + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + continue ; + }; +} + +function zipAux(_cellX, _cellY, _prec) { + while(true) { + var prec = _prec; + var cellY = _cellY; + var cellX = _cellX; + if (!cellX) { + return ; + } + if (!cellY) { + return ; + } + var next = { + hd: [ + cellX.hd, + cellY.hd + ], + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellY = cellY.tl; + _cellX = cellX.tl; + continue ; + }; +} + +function copyAuxWithMap2(f, _cellX, _cellY, _prec) { + while(true) { + var prec = _prec; + var cellY = _cellY; + var cellX = _cellX; + if (!cellX) { + return ; + } + if (!cellY) { + return ; + } + var next = { + hd: f(cellX.hd, cellY.hd), + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellY = cellY.tl; + _cellX = cellX.tl; + continue ; + }; +} + +function copyAuxWithMapI(f, _i, _cellX, _prec) { + while(true) { + var prec = _prec; + var cellX = _cellX; + var i = _i; + if (!cellX) { + return ; + } + var next = { + hd: f(i, cellX.hd), + tl: /* [] */0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + _i = i + 1 | 0; + continue ; + }; +} + +function takeAux(_n, _cell, _prec) { + while(true) { + var prec = _prec; + var cell = _cell; + var n = _n; + if (n === 0) { + return true; + } + if (!cell) { + return false; + } + var cell$1 = { + hd: cell.hd, + tl: /* [] */0 + }; + prec.tl = cell$1; + _prec = cell$1; + _cell = cell.tl; + _n = n - 1 | 0; + continue ; + }; +} + +function splitAtAux(_n, _cell, _prec) { + while(true) { + var prec = _prec; + var cell = _cell; + var n = _n; + if (n === 0) { + return cell; + } + if (!cell) { + return ; + } + var cell$1 = { + hd: cell.hd, + tl: /* [] */0 + }; + prec.tl = cell$1; + _prec = cell$1; + _cell = cell.tl; + _n = n - 1 | 0; + continue ; + }; +} + +function take(lst, n) { + if (n < 0) { + return ; + } + if (n === 0) { + return /* [] */0; + } + if (!lst) { + return ; + } + var cell = { + hd: lst.hd, + tl: /* [] */0 + }; + var has = takeAux(n - 1 | 0, lst.tl, cell); + if (has) { + return cell; + } + +} + +function drop(lst, n) { + if (n < 0) { + return ; + } else { + var _l = lst; + var _n = n; + while(true) { + var n$1 = _n; + var l = _l; + if (n$1 === 0) { + return l; + } + if (!l) { + return ; + } + _n = n$1 - 1 | 0; + _l = l.tl; + continue ; + }; + } +} + +function splitAt(lst, n) { + if (n < 0) { + return ; + } + if (n === 0) { + return [ + /* [] */0, + lst + ]; + } + if (!lst) { + return ; + } + var cell = { + hd: lst.hd, + tl: /* [] */0 + }; + var rest = splitAtAux(n - 1 | 0, lst.tl, cell); + if (rest !== undefined) { + return [ + cell, + rest + ]; + } + +} + +function concat(xs, ys) { + if (!xs) { + return ys; + } + var cell = { + hd: xs.hd, + tl: /* [] */0 + }; + copyAuxCont(xs.tl, cell).tl = ys; + return cell; +} + +function map(xs, f) { + var f$1 = function (x) { + return f(x); + }; + if (!xs) { + return /* [] */0; + } + var cell = { + hd: f$1(xs.hd), + tl: /* [] */0 + }; + copyAuxWithMap(xs.tl, cell, f$1); + return cell; +} + +function zipBy(l1, l2, f) { + var f$1 = function (x, y) { + return f(x, y); + }; + if (!l1) { + return /* [] */0; + } + if (!l2) { + return /* [] */0; + } + var cell = { + hd: f$1(l1.hd, l2.hd), + tl: /* [] */0 + }; + copyAuxWithMap2(f$1, l1.tl, l2.tl, cell); + return cell; +} + +function mapWithIndex(xs, f) { + var f$1 = function (i, x) { + return f(i, x); + }; + if (!xs) { + return /* [] */0; + } + var cell = { + hd: f$1(0, xs.hd), + tl: /* [] */0 + }; + copyAuxWithMapI(f$1, 1, xs.tl, cell); + return cell; +} + +function makeBy(n, f) { + var f$1 = function (x) { + return f(x); + }; + if (n <= 0) { + return /* [] */0; + } + var headX = { + hd: f$1(0), + tl: /* [] */0 + }; + var cur = headX; + var i = 1; + while(i < n) { + var v = { + hd: f$1(i), + tl: /* [] */0 + }; + cur.tl = v; + cur = v; + i = i + 1 | 0; + }; + return headX; +} + +function make(n, v) { + if (n <= 0) { + return /* [] */0; + } + var headX = { + hd: v, + tl: /* [] */0 + }; + var cur = headX; + var i = 1; + while(i < n) { + var v$1 = { + hd: v, + tl: /* [] */0 + }; + cur.tl = v$1; + cur = v$1; + i = i + 1 | 0; + }; + return headX; +} + +function length(xs) { + var _x = xs; + var _acc = 0; + while(true) { + var acc = _acc; + var x = _x; + if (!x) { + return acc; + } + _acc = acc + 1 | 0; + _x = x.tl; + continue ; + }; +} + +function fillAux(arr, _i, _x) { + while(true) { + var x = _x; + var i = _i; + if (!x) { + return ; + } + arr[i] = x.hd; + _x = x.tl; + _i = i + 1 | 0; + continue ; + }; +} + +function fromArray(a) { + var _i = a.length - 1 | 0; + var _res = /* [] */0; + while(true) { + var res = _res; + var i = _i; + if (i < 0) { + return res; + } + _res = { + hd: a[i], + tl: res + }; + _i = i - 1 | 0; + continue ; + }; +} + +function toArray(x) { + var len = length(x); + var arr = new Array(len); + fillAux(arr, 0, x); + return arr; +} + +function shuffle(xs) { + var v = toArray(xs); + Stdlib__Array.shuffleInPlace(v); + return fromArray(v); +} + +function reverseConcat(_l1, _l2) { + while(true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return l2; + } + _l2 = { + hd: l1.hd, + tl: l2 + }; + _l1 = l1.tl; + continue ; + }; +} + +function reverse(l) { + return reverseConcat(l, /* [] */0); +} + +function flattenAux(_prec, _xs) { + while(true) { + var xs = _xs; + var prec = _prec; + if (xs) { + _xs = xs.tl; + _prec = copyAuxCont(xs.hd, prec); + continue ; + } + prec.tl = /* [] */0; + return ; + }; +} + +function flatten(_xs) { + while(true) { + var xs = _xs; + if (!xs) { + return /* [] */0; + } + var match = xs.hd; + if (match) { + var cell = { + hd: match.hd, + tl: /* [] */0 + }; + flattenAux(copyAuxCont(match.tl, cell), xs.tl); + return cell; + } + _xs = xs.tl; + continue ; + }; +} + +function concatMany(xs) { + var len = xs.length; + if (len === 1) { + return xs[0]; + } + if (len === 0) { + return /* [] */0; + } + var len$1 = xs.length; + var v = xs[len$1 - 1 | 0]; + for(var i = len$1 - 2 | 0; i >= 0; --i){ + v = concat(xs[i], v); + } + return v; +} + +function mapReverse(l, f) { + var f$1 = function (x) { + return f(x); + }; + var _accu = /* [] */0; + var _xs = l; + while(true) { + var xs = _xs; + var accu = _accu; + if (!xs) { + return accu; + } + _xs = xs.tl; + _accu = { + hd: f$1(xs.hd), + tl: accu + }; + continue ; + }; +} + +function forEach(xs, f) { + var _xs = xs; + var f$1 = function (x) { + return f(x); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return ; + } + f$1(xs$1.hd); + _xs = xs$1.tl; + continue ; + }; +} + +function forEachWithIndex(l, f) { + var f$1 = function (i, x) { + return f(i, x); + }; + var _xs = l; + var _i = 0; + while(true) { + var i = _i; + var xs = _xs; + if (!xs) { + return ; + } + f$1(i, xs.hd); + _i = i + 1 | 0; + _xs = xs.tl; + continue ; + }; +} + +function reduce(l, accu, f) { + var _l = l; + var _accu = accu; + var f$1 = function (acc, x) { + return f(acc, x); + }; + while(true) { + var accu$1 = _accu; + var l$1 = _l; + if (!l$1) { + return accu$1; + } + _accu = f$1(accu$1, l$1.hd); + _l = l$1.tl; + continue ; + }; +} + +function reduceReverseUnsafeU(l, accu, f) { + if (l) { + return f(reduceReverseUnsafeU(l.tl, accu, f), l.hd); + } else { + return accu; + } +} + +function reduceReverse(l, accu, f) { + var f$1 = function (a, b) { + return f(a, b); + }; + var len = length(l); + if (len < 1000) { + return reduceReverseUnsafeU(l, accu, f$1); + } else { + return Belt_Array.reduceReverseU(toArray(l), accu, f$1); + } +} + +function reduceWithIndex(l, acc, f) { + var f$1 = function (acc, x, i) { + return f(acc, x, i); + }; + var _l = l; + var _acc = acc; + var _i = 0; + while(true) { + var i = _i; + var acc$1 = _acc; + var l$1 = _l; + if (!l$1) { + return acc$1; + } + _i = i + 1 | 0; + _acc = f$1(acc$1, l$1.hd, i); + _l = l$1.tl; + continue ; + }; +} + +function mapReverse2(l1, l2, f) { + var f$1 = function (a, b) { + return f(a, b); + }; + var _l1 = l1; + var _l2 = l2; + var _accu = /* [] */0; + while(true) { + var accu = _accu; + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return accu; + } + if (!l2$1) { + return accu; + } + _accu = { + hd: f$1(l1$1.hd, l2$1.hd), + tl: accu + }; + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function forEach2(l1, l2, f) { + var _l1 = l1; + var _l2 = l2; + var f$1 = function (a, b) { + return f(a, b); + }; + while(true) { + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return ; + } + if (!l2$1) { + return ; + } + f$1(l1$1.hd, l2$1.hd); + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function reduce2(l1, l2, acc, f) { + var _l1 = l1; + var _l2 = l2; + var _accu = acc; + var f$1 = function (a, b, c) { + return f(a, b, c); + }; + while(true) { + var accu = _accu; + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return accu; + } + if (!l2$1) { + return accu; + } + _accu = f$1(accu, l1$1.hd, l2$1.hd); + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function reduceReverse2UnsafeU(l1, l2, accu, f) { + if (l1 && l2) { + return f(reduceReverse2UnsafeU(l1.tl, l2.tl, accu, f), l1.hd, l2.hd); + } else { + return accu; + } +} + +function reduceReverse2(l1, l2, acc, f) { + var f$1 = function (a, b, c) { + return f(a, b, c); + }; + var len = length(l1); + if (len < 1000) { + return reduceReverse2UnsafeU(l1, l2, acc, f$1); + } else { + return Belt_Array.reduceReverse2U(toArray(l1), toArray(l2), acc, f$1); + } +} + +function every(xs, p) { + var _xs = xs; + var p$1 = function (x) { + return p(x); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return true; + } + if (!p$1(xs$1.hd)) { + return false; + } + _xs = xs$1.tl; + continue ; + }; +} + +function some(xs, p) { + var _xs = xs; + var p$1 = function (x) { + return p(x); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return false; + } + if (p$1(xs$1.hd)) { + return true; + } + _xs = xs$1.tl; + continue ; + }; +} + +function every2(l1, l2, p) { + var _l1 = l1; + var _l2 = l2; + var p$1 = function (a, b) { + return p(a, b); + }; + while(true) { + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return true; + } + if (!l2$1) { + return true; + } + if (!p$1(l1$1.hd, l2$1.hd)) { + return false; + } + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function cmpByLength(_l1, _l2) { + while(true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + if (l2) { + return -1; + } else { + return 0; + } + } + if (!l2) { + return 1; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue ; + }; +} + +function cmp(l1, l2, f) { + var _l1 = l1; + var _l2 = l2; + var p = function (x, y) { + return f(x, y); + }; + while(true) { + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + if (l2$1) { + return -1; + } else { + return 0; + } + } + if (!l2$1) { + return 1; + } + var c = p(l1$1.hd, l2$1.hd); + if (c !== 0) { + return c; + } + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function eq(l1, l2, f) { + var _l1 = l1; + var _l2 = l2; + var p = function (x, y) { + return f(x, y); + }; + while(true) { + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + if (l2$1) { + return false; + } else { + return true; + } + } + if (!l2$1) { + return false; + } + if (!p(l1$1.hd, l2$1.hd)) { + return false; + } + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function some2(l1, l2, p) { + var _l1 = l1; + var _l2 = l2; + var p$1 = function (a, b) { + return p(a, b); + }; + while(true) { + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return false; + } + if (!l2$1) { + return false; + } + if (p$1(l1$1.hd, l2$1.hd)) { + return true; + } + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue ; + }; +} + +function has(xs, x, eq) { + var _xs = xs; + var eq$1 = function (a, b) { + return eq(a, b); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return false; + } + if (eq$1(xs$1.hd, x)) { + return true; + } + _xs = xs$1.tl; + continue ; + }; +} + +function getAssoc(xs, x, eq) { + var _xs = xs; + var eq$1 = function (a, b) { + return eq(a, b); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return ; + } + var match = xs$1.hd; + if (eq$1(match[0], x)) { + return Caml_option.some(match[1]); + } + _xs = xs$1.tl; + continue ; + }; +} + +function hasAssoc(xs, x, eq) { + var _xs = xs; + var eq$1 = function (a, b) { + return eq(a, b); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return false; + } + if (eq$1(xs$1.hd[0], x)) { + return true; + } + _xs = xs$1.tl; + continue ; + }; +} + +function removeAssoc(xs, x, eq) { + var eq$1 = function (a, b) { + return eq(a, b); + }; + if (!xs) { + return /* [] */0; + } + var l = xs.tl; + var pair = xs.hd; + if (eq$1(pair[0], x)) { + return l; + } + var cell = { + hd: pair, + tl: /* [] */0 + }; + var removed = removeAssocAuxWithMap(l, x, cell, eq$1); + if (removed) { + return cell; + } else { + return xs; + } +} + +function setAssoc(xs, x, k, eq) { + var eq$1 = function (a, b) { + return eq(a, b); + }; + if (!xs) { + return { + hd: [ + x, + k + ], + tl: /* [] */0 + }; + } + var l = xs.tl; + var pair = xs.hd; + if (eq$1(pair[0], x)) { + return { + hd: [ + x, + k + ], + tl: l + }; + } + var cell = { + hd: pair, + tl: /* [] */0 + }; + var replaced = setAssocAuxWithMap(l, x, k, cell, eq$1); + if (replaced) { + return cell; + } else { + return { + hd: [ + x, + k + ], + tl: xs + }; + } +} + +function sort(xs, cmp) { + var cmp$1 = function (x, y) { + return cmp(x, y); + }; + var arr = toArray(xs); + Belt_SortArray.stableSortInPlaceByU(arr, cmp$1); + return fromArray(arr); +} + +function getBy(xs, p) { + var _xs = xs; + var p$1 = function (a) { + return p(a); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return ; + } + var x = xs$1.hd; + if (p$1(x)) { + return Caml_option.some(x); + } + _xs = xs$1.tl; + continue ; + }; +} + +function filter(xs, p) { + var _xs = xs; + var p$1 = function (x) { + return p(x); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return /* [] */0; + } + var t = xs$1.tl; + var h = xs$1.hd; + if (p$1(h)) { + var cell = { + hd: h, + tl: /* [] */0 + }; + copyAuxWitFilter(p$1, t, cell); + return cell; + } + _xs = t; + continue ; + }; +} + +function filterWithIndex(xs, p) { + var p$1 = function (x, i) { + return p(x, i); + }; + var _xs = xs; + var _i = 0; + while(true) { + var i = _i; + var xs$1 = _xs; + if (!xs$1) { + return /* [] */0; + } + var t = xs$1.tl; + var h = xs$1.hd; + if (p$1(h, i)) { + var cell = { + hd: h, + tl: /* [] */0 + }; + copyAuxWithFilterIndex(p$1, t, cell, i + 1 | 0); + return cell; + } + _i = i + 1 | 0; + _xs = t; + continue ; + }; +} + +function filterMap(xs, p) { + var _xs = xs; + var p$1 = function (x) { + return p(x); + }; + while(true) { + var xs$1 = _xs; + if (!xs$1) { + return /* [] */0; + } + var t = xs$1.tl; + var h = p$1(xs$1.hd); + if (h !== undefined) { + var cell = { + hd: Caml_option.valFromOption(h), + tl: /* [] */0 + }; + copyAuxWitFilterMap(p$1, t, cell); + return cell; + } + _xs = t; + continue ; + }; +} + +function partition(l, p) { + var p$1 = function (x) { + return p(x); + }; + if (!l) { + return [ + /* [] */0, + /* [] */0 + ]; + } + var h = l.hd; + var nextX = { + hd: h, + tl: /* [] */0 + }; + var nextY = { + hd: h, + tl: /* [] */0 + }; + var b = p$1(h); + partitionAux(p$1, l.tl, nextX, nextY); + if (b) { + return [ + nextX, + nextY.tl + ]; + } else { + return [ + nextX.tl, + nextY + ]; + } +} + +function unzip(xs) { + if (!xs) { + return [ + /* [] */0, + /* [] */0 + ]; + } + var match = xs.hd; + var cellX = { + hd: match[0], + tl: /* [] */0 + }; + var cellY = { + hd: match[1], + tl: /* [] */0 + }; + splitAux(xs.tl, cellX, cellY); + return [ + cellX, + cellY + ]; +} + +function zip(l1, l2) { + if (!l1) { + return /* [] */0; + } + if (!l2) { + return /* [] */0; + } + var cell = { + hd: [ + l1.hd, + l2.hd + ], + tl: /* [] */0 + }; + zipAux(l1.tl, l2.tl, cell); + return cell; +} + +var size = length; + +export { + length , + size , + head , + headExn , + tail , + tailExn , + add , + get , + getExn , + make , + makeBy , + shuffle , + drop , + take , + splitAt , + concat , + concatMany , + reverseConcat , + flatten , + map , + zip , + zipBy , + mapWithIndex , + fromArray , + toArray , + reverse , + mapReverse , + forEach , + forEachWithIndex , + reduce , + reduceWithIndex , + reduceReverse , + mapReverse2 , + forEach2 , + reduce2 , + reduceReverse2 , + every , + some , + every2 , + some2 , + cmpByLength , + cmp , + eq , + has , + getBy , + filter , + filterWithIndex , + filterMap , + partition , + unzip , + getAssoc , + hasAssoc , + removeAssoc , + setAssoc , + sort , +} +/* No side effect */ diff --git a/src/Stdlib__List.res b/src/Stdlib__List.res index 2b7f236..d0d4185 100644 --- a/src/Stdlib__List.res +++ b/src/Stdlib__List.res @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Hongbo Zhang, Authors of ReScript * * This program is free software: you can redistribute it and/or modify @@ -94,7 +95,7 @@ let head = x => let headExn = x => switch x { - | list{} => raise(Not_found) + | list{} => raise(. Not_found) | list{x, ..._} => x } @@ -106,7 +107,7 @@ let tail = x => let tailExn = x => switch x { - | list{} => raise(Not_found) + | list{} => raise(. Not_found) | list{_, ...t} => t } @@ -132,7 +133,7 @@ let rec nthAuxAssert = (x, n) => } else { nthAuxAssert(t, n - 1) } - | _ => raise(Not_found) + | _ => raise(. Not_found) } let get = (x, n) => @@ -144,7 +145,7 @@ let get = (x, n) => let getExn = (x, n) => if n < 0 { - raise(Not_found) + raise(. Not_found) } else { nthAuxAssert(x, n) } @@ -154,7 +155,7 @@ let rec partitionAux = (p, cell, precX, precY) => | list{} => () | list{h, ...t} => let next = mutableCell(h, list{}) - if p(. h) { + if p(h) { unsafeMutateTail(precX, next) partitionAux(p, t, next, precY) } else { @@ -190,7 +191,7 @@ let rec copyAuxWitFilter = (f, cellX, prec) => switch cellX { | list{} => () | list{h, ...t} => - if f(. h) { + if f(h) { let next = mutableCell(h, list{}) unsafeMutateTail(prec, next) copyAuxWitFilter(f, t, next) @@ -203,7 +204,7 @@ let rec copyAuxWithFilterIndex = (f, cellX, prec, i) => switch cellX { | list{} => () | list{h, ...t} => - if f(. h, i) { + if f(h, i) { let next = mutableCell(h, list{}) unsafeMutateTail(prec, next) copyAuxWithFilterIndex(f, t, next, i + 1) @@ -216,7 +217,7 @@ let rec copyAuxWitFilterMap = (f, cellX, prec) => switch cellX { | list{} => () | list{h, ...t} => - switch f(. h) { + switch f(h) { | Some(h) => let next = mutableCell(h, list{}) unsafeMutateTail(prec, next) @@ -229,7 +230,7 @@ let rec removeAssocAuxWithMap = (cellX, x, prec, f) => switch cellX { | list{} => false | list{(a, _) as h, ...t} => - if f(. a, x) { + if f(a, x) { unsafeMutateTail(prec, t) true } else { @@ -243,7 +244,7 @@ let rec setAssocAuxWithMap = (cellX, x, k, prec, eq) => switch cellX { | list{} => false | list{(a, _) as h, ...t} => - if eq(. a, x) { + if eq(a, x) { unsafeMutateTail(prec, list{(x, k), ...t}) true } else { @@ -257,7 +258,7 @@ let rec copyAuxWithMap = (cellX, prec, f) => switch cellX { | list{} => () | list{h, ...t} => - let next = mutableCell(f(. h), list{}) + let next = mutableCell(f(h), list{}) unsafeMutateTail(prec, next) copyAuxWithMap(t, next, f) } @@ -274,7 +275,7 @@ let rec zipAux = (cellX, cellY, prec) => let rec copyAuxWithMap2 = (f, cellX, cellY, prec) => switch (cellX, cellY) { | (list{h1, ...t1}, list{h2, ...t2}) => - let next = mutableCell(f(. h1, h2), list{}) + let next = mutableCell(f(h1, h2), list{}) unsafeMutateTail(prec, next) copyAuxWithMap2(f, t1, t2, next) | (list{}, _) | (_, list{}) => () @@ -283,7 +284,7 @@ let rec copyAuxWithMap2 = (f, cellX, cellY, prec) => let rec copyAuxWithMapI = (f, i, cellX, prec) => switch cellX { | list{h, ...t} => - let next = mutableCell(f(. i, h), list{}) + let next = mutableCell(f(i, h), list{}) unsafeMutateTail(prec, next) copyAuxWithMapI(f, i + 1, t, next) | list{} => () @@ -383,44 +384,44 @@ let mapU = (xs, f) => switch xs { | list{} => list{} | list{h, ...t} => - let cell = mutableCell(f(. h), list{}) + let cell = mutableCell(f(h), list{}) copyAuxWithMap(t, cell, f) cell } -let map = (xs, f) => mapU(xs, (. x) => f(x)) +let map = (xs, f) => mapU(xs, x => f(x)) let zipByU = (l1, l2, f) => switch (l1, l2) { | (list{a1, ...l1}, list{a2, ...l2}) => - let cell = mutableCell(f(. a1, a2), list{}) + let cell = mutableCell(f(a1, a2), list{}) copyAuxWithMap2(f, l1, l2, cell) cell | (list{}, _) | (_, list{}) => list{} } -let zipBy = (l1, l2, f) => zipByU(l1, l2, (. x, y) => f(x, y)) +let zipBy = (l1, l2, f) => zipByU(l1, l2, (x, y) => f(x, y)) let mapWithIndexU = (xs, f) => switch xs { | list{} => list{} | list{h, ...t} => - let cell = mutableCell(f(. 0, h), list{}) + let cell = mutableCell(f(0, h), list{}) copyAuxWithMapI(f, 1, t, cell) cell } -let mapWithIndex = (xs, f) => mapWithIndexU(xs, (. i, x) => f(i, x)) +let mapWithIndex = (xs, f) => mapWithIndexU(xs, (i, x) => f(i, x)) let makeByU = (n, f) => if n <= 0 { list{} } else { - let headX = mutableCell(f(. 0), list{}) - let cur = ref(headX) - let i = ref(1) + let headX = mutableCell(f(0), list{}) + let cur = ref(. headX) + let i = ref(. 1) while i.contents < n { - let v = mutableCell(f(. i.contents), list{}) + let v = mutableCell(f(i.contents), list{}) unsafeMutateTail(cur.contents, v) cur.contents = v i.contents = i.contents + 1 @@ -429,15 +430,15 @@ let makeByU = (n, f) => headX } -let makeBy = (n, f) => makeByU(n, (. x) => f(x)) +let makeBy = (n, f) => makeByU(n, x => f(x)) let make = (type a, n, v: a): list => if n <= 0 { list{} } else { let headX = mutableCell(v, list{}) - let cur = ref(headX) - let i = ref(1) + let cur = ref(. headX) + let i = ref(. 1) while i.contents < n { let v = mutableCell(v, list{}) unsafeMutateTail(cur.contents, v) @@ -476,7 +477,7 @@ let fromArray = a => fromArrayAux(a, Stdlib__Array.length(a) - 1, list{}) let toArray = (x: t<_>) => { let len = length(x) - let arr = A.makeUninitializedUnsafe(len) + let arr = A.makeUninitializedUnsafe(. len) fillAux(arr, 0, x) arr } @@ -537,7 +538,7 @@ let concatMany = xs => | [x] => x | _ => let len = Stdlib__Array.length(xs) - let v = ref(Stdlib__Array.getUnsafe(xs, len - 1)) + let v = ref(. Stdlib__Array.getUnsafe(xs, len - 1)) for i in len - 2 downto 0 { v.contents = concat(Stdlib__Array.getUnsafe(xs, i), v.contents) } @@ -547,46 +548,46 @@ let concatMany = xs => let rec mapRevAux = (f, accu, xs) => switch xs { | list{} => accu - | list{a, ...l} => mapRevAux(f, list{f(. a), ...accu}, l) + | list{a, ...l} => mapRevAux(f, list{f(a), ...accu}, l) } let mapReverseU = (l, f) => mapRevAux(f, list{}, l) -let mapReverse = (l, f) => mapReverseU(l, (. x) => f(x)) +let mapReverse = (l, f) => mapReverseU(l, x => f(x)) let rec forEachU = (xs, f) => switch xs { | list{} => () | list{a, ...l} => - f(. a)->ignore + f(a)->ignore forEachU(l, f) } -let forEach = (xs, f) => forEachU(xs, (. x) => f(x)) +let forEach = (xs, f) => forEachU(xs, x => f(x)) let rec iteri = (xs, i, f) => switch xs { | list{} => () | list{a, ...l} => - f(. i, a)->ignore + f(i, a)->ignore iteri(l, i + 1, f) } let forEachWithIndexU = (l, f) => iteri(l, 0, f) -let forEachWithIndex = (l, f) => forEachWithIndexU(l, (. i, x) => f(i, x)) +let forEachWithIndex = (l, f) => forEachWithIndexU(l, (i, x) => f(i, x)) let rec reduceU = (l, accu, f) => switch l { | list{} => accu - | list{a, ...l} => reduceU(l, f(. accu, a), f) + | list{a, ...l} => reduceU(l, f(accu, a), f) } -let reduce = (l, accu, f) => reduceU(l, accu, (. acc, x) => f(acc, x)) +let reduce = (l, accu, f) => reduceU(l, accu, (acc, x) => f(acc, x)) let rec reduceReverseUnsafeU = (l, accu, f) => switch l { | list{} => accu - | list{a, ...l} => f(. reduceReverseUnsafeU(l, accu, f), a) + | list{a, ...l} => f(reduceReverseUnsafeU(l, accu, f), a) } let reduceReverseU = (type a b, l: list, acc: b, f) => { @@ -594,54 +595,54 @@ let reduceReverseU = (type a b, l: list, acc: b, f) => { if len < 1000 { reduceReverseUnsafeU(l, acc, f) } else { - A.reduceReverseU(toArray(l), acc, f) + A.reduceReverseU(. toArray(l), acc, f) } } -let reduceReverse = (l, accu, f) => reduceReverseU(l, accu, (. a, b) => f(a, b)) +let reduceReverse = (l, accu, f) => reduceReverseU(l, accu, (a, b) => f(a, b)) let rec reduceWithIndexAuxU = (l, acc, f, i) => switch l { | list{} => acc - | list{x, ...xs} => reduceWithIndexAuxU(xs, f(. acc, x, i), f, i + 1) + | list{x, ...xs} => reduceWithIndexAuxU(xs, f(acc, x, i), f, i + 1) } let reduceWithIndexU = (l, acc, f) => reduceWithIndexAuxU(l, acc, f, 0) -let reduceWithIndex = (l, acc, f) => reduceWithIndexU(l, acc, (. acc, x, i) => f(acc, x, i)) +let reduceWithIndex = (l, acc, f) => reduceWithIndexU(l, acc, (acc, x, i) => f(acc, x, i)) let rec mapRevAux2 = (l1, l2, accu, f) => switch (l1, l2) { - | (list{a1, ...l1}, list{a2, ...l2}) => mapRevAux2(l1, l2, list{f(. a1, a2), ...accu}, f) + | (list{a1, ...l1}, list{a2, ...l2}) => mapRevAux2(l1, l2, list{f( a1, a2), ...accu}, f) | (_, list{}) | (list{}, _) => accu } let mapReverse2U = (l1, l2, f) => mapRevAux2(l1, l2, list{}, f) -let mapReverse2 = (l1, l2, f) => mapReverse2U(l1, l2, (. a, b) => f(a, b)) +let mapReverse2 = (l1, l2, f) => mapReverse2U(l1, l2, ( a, b) => f(a, b)) let rec forEach2U = (l1, l2, f) => switch (l1, l2) { | (list{a1, ...l1}, list{a2, ...l2}) => - f(. a1, a2)->ignore + f( a1, a2)->ignore forEach2U(l1, l2, f) | (list{}, _) | (_, list{}) => () } -let forEach2 = (l1, l2, f) => forEach2U(l1, l2, (. a, b) => f(a, b)) +let forEach2 = (l1, l2, f) => forEach2U(l1, l2, ( a, b) => f(a, b)) let rec reduce2U = (l1, l2, accu, f) => switch (l1, l2) { - | (list{a1, ...l1}, list{a2, ...l2}) => reduce2U(l1, l2, f(. accu, a1, a2), f) + | (list{a1, ...l1}, list{a2, ...l2}) => reduce2U(l1, l2, f( accu, a1, a2), f) | (list{}, _) | (_, list{}) => accu } -let reduce2 = (l1, l2, acc, f) => reduce2U(l1, l2, acc, (. a, b, c) => f(a, b, c)) +let reduce2 = (l1, l2, acc, f) => reduce2U(l1, l2, acc, ( a, b, c) => f(a, b, c)) let rec reduceReverse2UnsafeU = (l1, l2, accu, f) => switch (l1, l2) { | (list{}, list{}) => accu - | (list{a1, ...l1}, list{a2, ...l2}) => f(. reduceReverse2UnsafeU(l1, l2, accu, f), a1, a2) + | (list{a1, ...l1}, list{a2, ...l2}) => f(reduceReverse2UnsafeU(l1, l2, accu, f), a1, a2) | (_, list{}) | (list{}, _) => accu } @@ -650,35 +651,35 @@ let reduceReverse2U = (type a b c, l1: list, l2: list, acc: c, f) => { if len < 1000 { reduceReverse2UnsafeU(l1, l2, acc, f) } else { - A.reduceReverse2U(toArray(l1), toArray(l2), acc, f) + A.reduceReverse2U(. toArray(l1), toArray(l2), acc, f) } } -let reduceReverse2 = (l1, l2, acc, f) => reduceReverse2U(l1, l2, acc, (. a, b, c) => f(a, b, c)) +let reduceReverse2 = (l1, l2, acc, f) => reduceReverse2U(l1, l2, acc, (a, b, c) => f(a, b, c)) let rec everyU = (xs, p) => switch xs { | list{} => true - | list{a, ...l} => p(. a) && everyU(l, p) + | list{a, ...l} => p( a) && everyU(l, p) } -let every = (xs, p) => everyU(xs, (. x) => p(x)) +let every = (xs, p) => everyU(xs, ( x) => p(x)) let rec someU = (xs, p) => switch xs { | list{} => false - | list{a, ...l} => p(. a) || someU(l, p) + | list{a, ...l} => p( a) || someU(l, p) } -let some = (xs, p) => someU(xs, (. x) => p(x)) +let some = (xs, p) => someU(xs, ( x) => p(x)) let rec every2U = (l1, l2, p) => switch (l1, l2) { | (_, list{}) | (list{}, _) => true - | (list{a1, ...l1}, list{a2, ...l2}) => p(. a1, a2) && every2U(l1, l2, p) + | (list{a1, ...l1}, list{a2, ...l2}) => p( a1, a2) && every2U(l1, l2, p) } -let every2 = (l1, l2, p) => every2U(l1, l2, (. a, b) => p(a, b)) +let every2 = (l1, l2, p) => every2U(l1, l2, ( a, b) => p(a, b)) let rec cmpByLength = (l1, l2) => switch (l1, l2) { @@ -694,7 +695,7 @@ let rec cmpU = (l1, l2, p) => | (_, list{}) => 1 | (list{}, _) => -1 | (list{a1, ...l1}, list{a2, ...l2}) => - let c = p(. a1, a2) + let c = p( a1, a2) if c == 0 { cmpU(l1, l2, p) } else { @@ -702,7 +703,7 @@ let rec cmpU = (l1, l2, p) => } } -let cmp = (l1, l2, f) => cmpU(l1, l2, (. x, y) => f(x, y)) +let cmp = (l1, l2, f) => cmpU(l1, l2, ( x, y) => f(x, y)) let rec eqU = (l1, l2, p) => switch (l1, l2) { @@ -710,56 +711,56 @@ let rec eqU = (l1, l2, p) => | (_, list{}) | (list{}, _) => false | (list{a1, ...l1}, list{a2, ...l2}) => - if p(. a1, a2) { + if p( a1, a2) { eqU(l1, l2, p) } else { false } } -let eq = (l1, l2, f) => eqU(l1, l2, (. x, y) => f(x, y)) +let eq = (l1, l2, f) => eqU(l1, l2, ( x, y) => f(x, y)) let rec some2U = (l1, l2, p) => switch (l1, l2) { | (list{}, _) | (_, list{}) => false - | (list{a1, ...l1}, list{a2, ...l2}) => p(. a1, a2) || some2U(l1, l2, p) + | (list{a1, ...l1}, list{a2, ...l2}) => p( a1, a2) || some2U(l1, l2, p) } -let some2 = (l1, l2, p) => some2U(l1, l2, (. a, b) => p(a, b)) +let some2 = (l1, l2, p) => some2U(l1, l2, ( a, b) => p(a, b)) let rec hasU = (xs, x, eq) => switch xs { | list{} => false - | list{a, ...l} => eq(. a, x) || hasU(l, x, eq) + | list{a, ...l} => eq( a, x) || hasU(l, x, eq) } -let has = (xs, x, eq) => hasU(xs, x, (. a, b) => eq(a, b)) +let has = (xs, x, eq) => hasU(xs, x, ( a, b) => eq(a, b)) let rec getAssocU = (xs, x, eq) => switch xs { | list{} => None | list{(a, b), ...l} => - if eq(. a, x) { + if eq( a, x) { Some(b) } else { getAssocU(l, x, eq) } } -let getAssoc = (xs, x, eq) => getAssocU(xs, x, (. a, b) => eq(a, b)) +let getAssoc = (xs, x, eq) => getAssocU(xs, x, ( a, b) => eq(a, b)) let rec hasAssocU = (xs, x, eq) => switch xs { | list{} => false - | list{(a, _), ...l} => eq(. a, x) || hasAssocU(l, x, eq) + | list{(a, _), ...l} => eq( a, x) || hasAssocU(l, x, eq) } -let hasAssoc = (xs, x, eq) => hasAssocU(xs, x, (. a, b) => eq(a, b)) +let hasAssoc = (xs, x, eq) => hasAssocU(xs, x, ( a, b) => eq(a, b)) let removeAssocU = (xs, x, eq) => switch xs { | list{} => list{} | list{(a, _) as pair, ...l} => - if eq(. a, x) { + if eq( a, x) { l } else { let cell = mutableCell(pair, list{}) @@ -772,13 +773,13 @@ let removeAssocU = (xs, x, eq) => } } -let removeAssoc = (xs, x, eq) => removeAssocU(xs, x, (. a, b) => eq(a, b)) +let removeAssoc = (xs, x, eq) => removeAssocU(xs, x, ( a, b) => eq(a, b)) let setAssocU = (xs, x, k, eq) => switch xs { | list{} => list{(x, k)} | list{(a, _) as pair, ...l} => - if eq(. a, x) { + if eq( a, x) { list{(x, k), ...l} } else { let cell = mutableCell(pair, list{}) @@ -791,34 +792,34 @@ let setAssocU = (xs, x, k, eq) => } } -let setAssoc = (xs, x, k, eq) => setAssocU(xs, x, k, (. a, b) => eq(a, b)) +let setAssoc = (xs, x, k, eq) => setAssocU(xs, x, k, ( a, b) => eq(a, b)) let sortU = (xs, cmp) => { let arr = toArray(xs) - Belt_SortArray.stableSortInPlaceByU(arr, cmp) + Belt_SortArray.stableSortInPlaceByU(. arr, cmp) fromArray(arr) } -let sort = (xs, cmp) => sortU(xs, (. x, y) => cmp(x, y)) +let sort = (xs, cmp) => sortU(xs, (x, y) => cmp(x, y)) let rec getByU = (xs, p) => switch xs { | list{} => None | list{x, ...l} => - if p(. x) { + if p( x) { Some(x) } else { getByU(l, p) } } -let getBy = (xs, p) => getByU(xs, (. a) => p(a)) +let getBy = (xs, p) => getByU(xs, ( a) => p(a)) let rec filterU = (xs, p) => switch xs { | list{} => list{} | list{h, ...t} => - if p(. h) { + if p(h) { let cell = mutableCell(h, list{}) copyAuxWitFilter(p, t, cell) cell @@ -827,14 +828,14 @@ let rec filterU = (xs, p) => } } -let filter = (xs, p) => filterU(xs, (. x) => p(x)) +let filter = (xs, p) => filterU(xs, x => p(x)) let filterWithIndexU = (xs, p) => { let rec auxFilterWithIndex = (xs, p, i) => switch xs { | list{} => list{} | list{h, ...t} => - if p(. h, i) { + if p(h, i) { let cell = mutableCell(h, list{}) copyAuxWithFilterIndex(p, t, cell, i + 1) cell @@ -845,13 +846,13 @@ let filterWithIndexU = (xs, p) => { auxFilterWithIndex(xs, p, 0) } -let filterWithIndex = (xs, p) => filterWithIndexU(xs, (. x, i) => p(x, i)) +let filterWithIndex = (xs, p) => filterWithIndexU(xs, (x, i) => p(x, i)) let rec filterMapU = (xs, p) => switch xs { | list{} => list{} | list{h, ...t} => - switch p(. h) { + switch p(h) { | Some(h) => let cell = mutableCell(h, list{}) copyAuxWitFilterMap(p, t, cell) @@ -860,7 +861,7 @@ let rec filterMapU = (xs, p) => } } -let filterMap = (xs, p) => filterMapU(xs, (. x) => p(x)) +let filterMap = (xs, p) => filterMapU(xs, x => p(x)) let partitionU = (l, p) => switch l { @@ -868,7 +869,7 @@ let partitionU = (l, p) => | list{h, ...t} => let nextX = mutableCell(h, list{}) let nextY = mutableCell(h, list{}) - let b = p(. h) + let b = p(h) partitionAux(p, t, nextX, nextY) if b { ( @@ -889,7 +890,7 @@ let partitionU = (l, p) => } } -let partition = (l, p) => partitionU(l, (. x) => p(x)) +let partition = (l, p) => partitionU(l, x => p(x)) let unzip = xs => switch xs { diff --git a/src/Stdlib__List.resi b/src/Stdlib__List.resi index 72e7adb..a50c5c4 100644 --- a/src/Stdlib__List.resi +++ b/src/Stdlib__List.resi @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Authors of ReScript * * This program is free software: you can redistribute it and/or modify diff --git a/src/Stdlib__Map.mjs b/src/Stdlib__Map.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Map.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Map.res b/src/Stdlib__Map.res index fef86b3..060b357 100644 --- a/src/Stdlib__Map.res +++ b/src/Stdlib__Map.res @@ -1,3 +1,4 @@ +@@uncurried type t<'k, 'v> @new external make: unit => t<'k, 'v> = "Map" diff --git a/src/Stdlib__Math.mjs b/src/Stdlib__Math.mjs new file mode 100644 index 0000000..87e83ff --- /dev/null +++ b/src/Stdlib__Math.mjs @@ -0,0 +1,12 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +var Int = {}; + +export { + Constants , + Int , +} +/* No side effect */ diff --git a/src/Stdlib__Math.res b/src/Stdlib__Math.res index c9b7497..eb90085 100644 --- a/src/Stdlib__Math.res +++ b/src/Stdlib__Math.res @@ -1,3 +1,4 @@ +@@uncurried module Constants = { @val external e: float = "Math.E" @val external ln2: float = "Math.LN2" diff --git a/src/Stdlib__Null.mjs b/src/Stdlib__Null.mjs new file mode 100644 index 0000000..9bbfc49 --- /dev/null +++ b/src/Stdlib__Null.mjs @@ -0,0 +1,16 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_option from "rescript/lib/es6/caml_option.js"; + +function fromOption(option) { + if (option !== undefined) { + return Caml_option.valFromOption(option); + } else { + return null; + } +} + +export { + fromOption , +} +/* No side effect */ diff --git a/src/Stdlib__Null.res b/src/Stdlib__Null.res index 525d639..244392f 100644 --- a/src/Stdlib__Null.res +++ b/src/Stdlib__Null.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> = Js.Null.t<'a> external asNullable: t<'a> => Stdlib__Nullable.t<'a> = "%identity" diff --git a/src/Stdlib__Nullable.mjs b/src/Stdlib__Nullable.mjs new file mode 100644 index 0000000..bdc0e58 --- /dev/null +++ b/src/Stdlib__Nullable.mjs @@ -0,0 +1,15 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_option from "rescript/lib/es6/caml_option.js"; + +function fromOption(option) { + if (option !== undefined) { + return Caml_option.valFromOption(option); + } + +} + +export { + fromOption , +} +/* No side effect */ diff --git a/src/Stdlib__Nullable.res b/src/Stdlib__Nullable.res index 2f3e9a2..bcd2af4 100644 --- a/src/Stdlib__Nullable.res +++ b/src/Stdlib__Nullable.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> = Js.Nullable.t<'a> external null: t<'a> = "#null" diff --git a/src/Stdlib__Object.mjs b/src/Stdlib__Object.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Object.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Object.res b/src/Stdlib__Object.res index 496324f..af4832a 100644 --- a/src/Stdlib__Object.res +++ b/src/Stdlib__Object.res @@ -1,3 +1,4 @@ +@@uncurried @obj external empty: unit => {..} = "" @val external is: ('a, 'b) => bool = "Object.is" diff --git a/src/Stdlib__Option.mjs b/src/Stdlib__Option.mjs new file mode 100644 index 0000000..dcbdd10 --- /dev/null +++ b/src/Stdlib__Option.mjs @@ -0,0 +1,136 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_option from "rescript/lib/es6/caml_option.js"; + +function filter(opt, p) { + var p$1 = function (x) { + return p(x); + }; + if (opt !== undefined && p$1(Caml_option.valFromOption(opt))) { + return opt; + } + +} + +function forEach(opt, f) { + var f$1 = function (x) { + f(x); + }; + if (opt !== undefined) { + return f$1(Caml_option.valFromOption(opt)); + } + +} + +function getExn(x) { + if (x !== undefined) { + return Caml_option.valFromOption(x); + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; +} + +function mapWithDefault(opt, $$default, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt !== undefined) { + return f$1(Caml_option.valFromOption(opt)); + } else { + return $$default; + } +} + +function map(opt, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt !== undefined) { + return Caml_option.some(f$1(Caml_option.valFromOption(opt))); + } + +} + +function flatMap(opt, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt !== undefined) { + return f$1(Caml_option.valFromOption(opt)); + } + +} + +function getWithDefault(opt, $$default) { + if (opt !== undefined) { + return Caml_option.valFromOption(opt); + } else { + return $$default; + } +} + +function orElse(opt, other) { + if (opt !== undefined) { + return opt; + } else { + return other; + } +} + +function isSome(x) { + return x !== undefined; +} + +function isNone(x) { + return x === undefined; +} + +function eq(a, b, f) { + var f$1 = function (x, y) { + return f(x, y); + }; + if (a !== undefined) { + if (b !== undefined) { + return f$1(Caml_option.valFromOption(a), Caml_option.valFromOption(b)); + } else { + return false; + } + } else { + return b === undefined; + } +} + +function cmp(a, b, f) { + var f$1 = function (x, y) { + return f(x, y); + }; + if (a !== undefined) { + if (b !== undefined) { + return f$1(Caml_option.valFromOption(a), Caml_option.valFromOption(b)); + } else { + return 1; + } + } else if (b !== undefined) { + return -1; + } else { + return 0; + } +} + +export { + filter , + forEach , + getExn , + mapWithDefault , + map , + flatMap , + getWithDefault , + orElse , + isSome , + isNone , + eq , + cmp , +} +/* No side effect */ diff --git a/src/Stdlib__Option.res b/src/Stdlib__Option.res index 9b68864..9493d04 100644 --- a/src/Stdlib__Option.res +++ b/src/Stdlib__Option.res @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Hongbo Zhang, Authors of ReScript * * This program is free software: you can redistribute it and/or modify @@ -24,51 +25,51 @@ let filterU = (opt, p) => switch opt { - | Some(x) as some if p(. x) => some + | Some(x) as some if p(x) => some | _ => None } -let filter = (opt, p) => filterU(opt, (. x) => p(x)) +let filter = (opt, p) => filterU(opt, x => p(x)) let forEachU = (opt, f) => switch opt { - | Some(x) => f(. x) + | Some(x) => f(x) | None => () } -let forEach = (opt, f) => forEachU(opt, (. x) => f(x)) +let forEach = (opt, f) => forEachU(opt, x => f(x)) let getExn = x => switch x { | Some(x) => x - | None => raise(Not_found) + | None => raise(. Not_found) } external getUnsafe: option<'a> => 'a = "%identity" let mapWithDefaultU = (opt, default, f) => switch opt { - | Some(x) => f(. x) + | Some(x) => f(x) | None => default } -let mapWithDefault = (opt, default, f) => mapWithDefaultU(opt, default, (. x) => f(x)) +let mapWithDefault = (opt, default, f) => mapWithDefaultU(opt, default, x => f(x)) let mapU = (opt, f) => switch opt { - | Some(x) => Some(f(. x)) + | Some(x) => Some(f(x)) | None => None } -let map = (opt, f) => mapU(opt, (. x) => f(x)) +let map = (opt, f) => mapU(opt, x => f(x)) let flatMapU = (opt, f) => switch opt { - | Some(x) => f(. x) + | Some(x) => f(x) | None => None } -let flatMap = (opt, f) => flatMapU(opt, (. x) => f(x)) +let flatMap = (opt, f) => flatMapU(opt, x => f(x)) let getWithDefault = (opt, default) => switch opt { @@ -95,19 +96,19 @@ let eqU = (a, b, f) => | Some(a) => switch b { | None => false - | Some(b) => f(. a, b) + | Some(b) => f(a, b) } | None => b == None } -let eq = (a, b, f) => eqU(a, b, (. x, y) => f(x, y)) +let eq = (a, b, f) => eqU(a, b, (x, y) => f(x, y)) let cmpU = (a, b, f) => switch (a, b) { - | (Some(a), Some(b)) => f(. a, b) + | (Some(a), Some(b)) => f(a, b) | (None, Some(_)) => -1 | (Some(_), None) => 1 | (None, None) => 0 } -let cmp = (a, b, f) => cmpU(a, b, (. x, y) => f(x, y)) +let cmp = (a, b, f) => cmpU(a, b, (x, y) => f(x, y)) diff --git a/src/Stdlib__Option.resi b/src/Stdlib__Option.resi index daa09d8..e04d15b 100644 --- a/src/Stdlib__Option.resi +++ b/src/Stdlib__Option.resi @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Authors of ReScript * * This program is free software: you can redistribute it and/or modify diff --git a/src/Stdlib__Promise.mjs b/src/Stdlib__Promise.mjs new file mode 100644 index 0000000..d2e12b4 --- /dev/null +++ b/src/Stdlib__Promise.mjs @@ -0,0 +1,23 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js"; + +var then = (function(p, cont) { + Promise.resolve(p).then(cont) +}); + +var _catch = (function(p, cont) { + Promise.resolve(p).catch(cont) +}); + +function $$catch(promise, callback) { + return _catch(promise, (function (err) { + return callback(Caml_js_exceptions.internalToOCamlException(err)); + })); +} + +export { + $$catch , + then , +} +/* No side effect */ diff --git a/src/Stdlib__Promise.res b/src/Stdlib__Promise.res index 04ee44c..c13cd3f 100644 --- a/src/Stdlib__Promise.res +++ b/src/Stdlib__Promise.res @@ -1,7 +1,8 @@ +@@uncurried type t<+'a> = promise<'a> @new -external make: ((@uncurry (. 'a) => unit, (. 'e) => unit) => unit) => t<'a> = "Promise" +external make: (('a => unit, 'e => unit) => unit) => t<'a> = "Promise" @val @scope("Promise") external resolve: 'a => t<'a> = "resolve" @@ -11,7 +12,7 @@ let then: (promise<'a>, 'a => promise<'b>) => promise<'b> = %raw(`function(p, co }`) @send -external thenResolve: (t<'a>, @uncurry ('a => 'b)) => t<'b> = "then" +external thenResolve: (t<'a>, 'a => 'b) => t<'b> = "then" @send external finally: (t<'a>, unit => unit) => t<'a> = "finally" @@ -44,7 +45,7 @@ let _catch: (promise<'a>, error => promise<'a>) => promise<'a> = %raw(`function( let catch = (promise: promise<'a>, callback: exn => promise<'a>): promise<'a> => { _catch(promise, err => { - callback(Js.Exn.anyToExnInternal(err)) + callback(Js.Exn.anyToExnInternal(. err)) }) } diff --git a/src/Stdlib__Promise.resi b/src/Stdlib__Promise.resi index d90b91f..8caed2d 100644 --- a/src/Stdlib__Promise.resi +++ b/src/Stdlib__Promise.resi @@ -1,3 +1,4 @@ +@@uncurried // The +'a marks the abstract type parameter as covariant, which essentially means that // a value of type 'a is immutable and may not be used in some mutable context. // @@ -49,7 +50,7 @@ Promise.make((resolve, reject) => { ``` */ @new -external make: ((@uncurry (. 'a) => unit, (. 'e) => unit) => unit) => t<'a> = "Promise" +external make: (('a => unit, 'e => unit) => unit) => t<'a> = "Promise" /** `catch(promise, errorCallback)` registers an exception handler in a promise chain. @@ -130,7 +131,7 @@ resolve(\"Anna\") In case you want to return another promise in your `callback`, consider using \`then\` instead. */ @send -external thenResolve: (t<'a>, @uncurry ('a => 'b)) => t<'b> = "then" +external thenResolve: (t<'a>, 'a => 'b) => t<'b> = "then" /** [finally(promise, callback)] is used to execute a function that is called no matter if a promise diff --git a/src/Stdlib__RegExp.mjs b/src/Stdlib__RegExp.mjs new file mode 100644 index 0000000..bb9301b --- /dev/null +++ b/src/Stdlib__RegExp.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Result = {}; + +export { + Result , +} +/* No side effect */ diff --git a/src/Stdlib__RegExp.res b/src/Stdlib__RegExp.res index 794a78d..9ec93b7 100644 --- a/src/Stdlib__RegExp.res +++ b/src/Stdlib__RegExp.res @@ -1,3 +1,4 @@ +@@uncurried type t = Js.Re.t module Result = { diff --git a/src/Stdlib__Result.mjs b/src/Stdlib__Result.mjs new file mode 100644 index 0000000..a52c381 --- /dev/null +++ b/src/Stdlib__Result.mjs @@ -0,0 +1,125 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function getExn(x) { + if (x.TAG === /* Ok */0) { + return x._0; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; +} + +function mapWithDefault(opt, $$default, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt.TAG === /* Ok */0) { + return f$1(opt._0); + } else { + return $$default; + } +} + +function map(opt, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt.TAG === /* Ok */0) { + return { + TAG: /* Ok */0, + _0: f$1(opt._0) + }; + } else { + return { + TAG: /* Error */1, + _0: opt._0 + }; + } +} + +function flatMap(opt, f) { + var f$1 = function (x) { + return f(x); + }; + if (opt.TAG === /* Ok */0) { + return f$1(opt._0); + } else { + return { + TAG: /* Error */1, + _0: opt._0 + }; + } +} + +function getWithDefault(opt, $$default) { + if (opt.TAG === /* Ok */0) { + return opt._0; + } else { + return $$default; + } +} + +function isOk(x) { + if (x.TAG === /* Ok */0) { + return true; + } else { + return false; + } +} + +function isError(x) { + if (x.TAG === /* Ok */0) { + return false; + } else { + return true; + } +} + +function eq(a, b, f) { + var f$1 = function (x, y) { + return f(x, y); + }; + if (a.TAG === /* Ok */0) { + if (b.TAG === /* Ok */0) { + return f$1(a._0, b._0); + } else { + return false; + } + } else if (b.TAG === /* Ok */0) { + return false; + } else { + return true; + } +} + +function cmp(a, b, f) { + var f$1 = function (x, y) { + return f(x, y); + }; + if (a.TAG === /* Ok */0) { + if (b.TAG === /* Ok */0) { + return f$1(a._0, b._0); + } else { + return 1; + } + } else if (b.TAG === /* Ok */0) { + return -1; + } else { + return 0; + } +} + +export { + getExn , + mapWithDefault , + map , + flatMap , + getWithDefault , + isOk , + isError , + eq , + cmp , +} +/* No side effect */ diff --git a/src/Stdlib__Result.res b/src/Stdlib__Result.res index 51032a6..82dc600 100644 --- a/src/Stdlib__Result.res +++ b/src/Stdlib__Result.res @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Hongbo Zhang, Authors of ReScript * * This program is free software: you can redistribute it and/or modify @@ -27,32 +28,32 @@ type t<'a, 'b> = result<'a, 'b> = Ok('a) | Error('b) let getExn = x => switch x { | Ok(x) => x - | Error(_) => raise(Not_found) + | Error(_) => raise(. Not_found) } let mapWithDefaultU = (opt, default, f) => switch opt { - | Ok(x) => f(. x) + | Ok(x) => f(x) | Error(_) => default } -let mapWithDefault = (opt, default, f) => mapWithDefaultU(opt, default, (. x) => f(x)) +let mapWithDefault = (opt, default, f) => mapWithDefaultU(opt, default, x => f(x)) let mapU = (opt, f) => switch opt { - | Ok(x) => Ok(f(. x)) + | Ok(x) => Ok(f(x)) | Error(y) => Error(y) } -let map = (opt, f) => mapU(opt, (. x) => f(x)) +let map = (opt, f) => mapU(opt, x => f(x)) let flatMapU = (opt, f) => switch opt { - | Ok(x) => f(. x) + | Ok(x) => f(x) | Error(y) => Error(y) } -let flatMap = (opt, f) => flatMapU(opt, (. x) => f(x)) +let flatMap = (opt, f) => flatMapU(opt, x => f(x)) let getWithDefault = (opt, default) => switch opt { @@ -74,20 +75,20 @@ let isError = x => let eqU = (a, b, f) => switch (a, b) { - | (Ok(a), Ok(b)) => f(. a, b) + | (Ok(a), Ok(b)) => f(a, b) | (Error(_), Ok(_)) | (Ok(_), Error(_)) => false | (Error(_), Error(_)) => true } -let eq = (a, b, f) => eqU(a, b, (. x, y) => f(x, y)) +let eq = (a, b, f) => eqU(a, b, (x, y) => f(x, y)) let cmpU = (a, b, f) => switch (a, b) { - | (Ok(a), Ok(b)) => f(. a, b) + | (Ok(a), Ok(b)) => f(a, b) | (Error(_), Ok(_)) => -1 | (Ok(_), Error(_)) => 1 | (Error(_), Error(_)) => 0 } -let cmp = (a, b, f) => cmpU(a, b, (. x, y) => f(x, y)) +let cmp = (a, b, f) => cmpU(a, b, (x, y) => f(x, y)) diff --git a/src/Stdlib__Result.resi b/src/Stdlib__Result.resi index acf4fd9..4a3dbf4 100644 --- a/src/Stdlib__Result.resi +++ b/src/Stdlib__Result.resi @@ -1,3 +1,4 @@ +@@uncurried /* Copyright (C) 2017 Authors of ReScript * * This program is free software: you can redistribute it and/or modify diff --git a/src/Stdlib__Serializer.mjs b/src/Stdlib__Serializer.mjs new file mode 100644 index 0000000..909783b --- /dev/null +++ b/src/Stdlib__Serializer.mjs @@ -0,0 +1,41 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function encodeUndefined(_key, value) { + if (value === undefined) { + return { + __rescript_private_none: true + }; + } else { + return value; + } +} + +function serializeExn(x) { + return JSON.stringify(x, encodeUndefined); +} + +function deserializeUnsafe(x) { + var undefinedValues = []; + var value = JSON.parse(x, (function (key, value) { + var $$this = this ; + if (!(value == null) && value.__rescript_private_none) { + undefinedValues.push([ + $$this, + key + ]); + } + return value; + })); + undefinedValues.forEach(function (param) { + param[0][param[1]] = undefined; + }); + return value; +} + +export { + encodeUndefined , + serializeExn , + deserializeUnsafe , +} +/* No side effect */ diff --git a/src/Stdlib__Serializer.res b/src/Stdlib__Serializer.res index 57ba68d..893dac9 100644 --- a/src/Stdlib__Serializer.res +++ b/src/Stdlib__Serializer.res @@ -1,3 +1,4 @@ +@@uncurried type undefined = {__rescript_private_none: bool} let encodeUndefined = (_key, value) => diff --git a/src/Stdlib__Set.mjs b/src/Stdlib__Set.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Set.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Set.res b/src/Stdlib__Set.res index c28b00e..70a5c0a 100644 --- a/src/Stdlib__Set.res +++ b/src/Stdlib__Set.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> @new external make: unit => t<'a> = "Set" diff --git a/src/Stdlib__String.mjs b/src/Stdlib__String.mjs new file mode 100644 index 0000000..1b8a0b9 --- /dev/null +++ b/src/Stdlib__String.mjs @@ -0,0 +1,33 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function indexOfOpt(s, search) { + var index = s.indexOf(search); + if (index !== -1) { + return index; + } + +} + +function lastIndexOfOpt(s, search) { + var index = s.lastIndexOf(search); + if (index !== -1) { + return index; + } + +} + +function searchOpt(s, re) { + var index = s.search(re); + if (index !== -1) { + return index; + } + +} + +export { + indexOfOpt , + lastIndexOfOpt , + searchOpt , +} +/* No side effect */ diff --git a/src/Stdlib__String.res b/src/Stdlib__String.res index 0215167..01480c3 100644 --- a/src/Stdlib__String.res +++ b/src/Stdlib__String.res @@ -1,3 +1,4 @@ +@@uncurried @val external make: 'a => string = "String" @val external fromCharCode: int => string = "String.fromCharCode" diff --git a/src/Stdlib__Symbol.mjs b/src/Stdlib__Symbol.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__Symbol.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__Symbol.res b/src/Stdlib__Symbol.res index 1dc2b9b..e7d496b 100644 --- a/src/Stdlib__Symbol.res +++ b/src/Stdlib__Symbol.res @@ -1,3 +1,4 @@ +@@uncurried type t @val external make: string => t = "Symbol" diff --git a/src/Stdlib__Type.mjs b/src/Stdlib__Type.mjs new file mode 100644 index 0000000..8ea2b64 --- /dev/null +++ b/src/Stdlib__Type.mjs @@ -0,0 +1,53 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +function classify(value) { + var match = Object.prototype.toString.call(value); + switch (match) { + case "[object Boolean]" : + return { + TAG: /* Bool */0, + _0: value + }; + case "[object AsyncFunction]" : + case "[object Function]" : + case "[object GeneratorFunction]" : + return { + TAG: /* Function */4, + _0: value + }; + case "[object Null]" : + return /* Null */0; + case "[object Number]" : + return { + TAG: /* Number */2, + _0: value + }; + case "[object String]" : + return { + TAG: /* String */1, + _0: value + }; + case "[object Symbol]" : + return { + TAG: /* Symbol */5, + _0: value + }; + case "[object Undefined]" : + return /* Undefined */1; + default: + return { + TAG: /* Object */3, + _0: value + }; + } +} + +var Classify = { + classify: classify +}; + +export { + Classify , +} +/* No side effect */ diff --git a/src/Stdlib__Type.res b/src/Stdlib__Type.res index aaea180..e4a0a0d 100644 --- a/src/Stdlib__Type.res +++ b/src/Stdlib__Type.res @@ -1,3 +1,4 @@ +@@uncurried type t = [#undefined | #object | #boolean | #number | #bigint | #string | #symbol | #function] external typeof: 'a => t = "#typeof" diff --git a/src/Stdlib__Undefined.mjs b/src/Stdlib__Undefined.mjs new file mode 100644 index 0000000..bdc0e58 --- /dev/null +++ b/src/Stdlib__Undefined.mjs @@ -0,0 +1,15 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_option from "rescript/lib/es6/caml_option.js"; + +function fromOption(option) { + if (option !== undefined) { + return Caml_option.valFromOption(option); + } + +} + +export { + fromOption , +} +/* No side effect */ diff --git a/src/Stdlib__Undefined.res b/src/Stdlib__Undefined.res index 8385a46..7cebd41 100644 --- a/src/Stdlib__Undefined.res +++ b/src/Stdlib__Undefined.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> = Js.Undefined.t<'a> external asNullable: t<'a> => Stdlib__Nullable.t<'a> = "%identity" diff --git a/src/Stdlib__WeakMap.mjs b/src/Stdlib__WeakMap.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__WeakMap.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__WeakMap.res b/src/Stdlib__WeakMap.res index 42dde98..d5b95b1 100644 --- a/src/Stdlib__WeakMap.res +++ b/src/Stdlib__WeakMap.res @@ -1,3 +1,4 @@ +@@uncurried type t<'k, 'v> @new external make: unit => t<'k, 'v> = "WeakMap" diff --git a/src/Stdlib__WeakSet.mjs b/src/Stdlib__WeakSet.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/Stdlib__WeakSet.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/Stdlib__WeakSet.res b/src/Stdlib__WeakSet.res index b8c17e9..4c6c6f7 100644 --- a/src/Stdlib__WeakSet.res +++ b/src/Stdlib__WeakSet.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> @new external make: unit => t<'a> = "WeakSet" diff --git a/src/intl/Stdlib__Intl__Collator.mjs b/src/intl/Stdlib__Intl__Collator.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__Collator.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__Collator.res b/src/intl/Stdlib__Intl__Collator.res index dce5716..b34e461 100644 --- a/src/intl/Stdlib__Intl__Collator.res +++ b/src/intl/Stdlib__Intl__Collator.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: unit => t = "Intl.Collator" diff --git a/src/intl/Stdlib__Intl__DateTimeFormat.mjs b/src/intl/Stdlib__Intl__DateTimeFormat.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__DateTimeFormat.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__DateTimeFormat.res b/src/intl/Stdlib__Intl__DateTimeFormat.res index de0f063..7e1e2f3 100644 --- a/src/intl/Stdlib__Intl__DateTimeFormat.res +++ b/src/intl/Stdlib__Intl__DateTimeFormat.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: unit => t = "Intl.DateTimeFormat" diff --git a/src/intl/Stdlib__Intl__Locale.mjs b/src/intl/Stdlib__Intl__Locale.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__Locale.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__Locale.res b/src/intl/Stdlib__Intl__Locale.res index b2ecec9..3e97d0b 100644 --- a/src/intl/Stdlib__Intl__Locale.res +++ b/src/intl/Stdlib__Intl__Locale.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: string => t = "Intl.Locale" diff --git a/src/intl/Stdlib__Intl__NumberFormat.mjs b/src/intl/Stdlib__Intl__NumberFormat.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__NumberFormat.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__NumberFormat.res b/src/intl/Stdlib__Intl__NumberFormat.res index 4851c07..8795585 100644 --- a/src/intl/Stdlib__Intl__NumberFormat.res +++ b/src/intl/Stdlib__Intl__NumberFormat.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: unit => t = "Intl.NumberFormat" diff --git a/src/intl/Stdlib__Intl__PluralRules.mjs b/src/intl/Stdlib__Intl__PluralRules.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__PluralRules.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__PluralRules.res b/src/intl/Stdlib__Intl__PluralRules.res index cf1e1ed..dfa15e7 100644 --- a/src/intl/Stdlib__Intl__PluralRules.res +++ b/src/intl/Stdlib__Intl__PluralRules.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: unit => t = "Intl.PluralRules" diff --git a/src/intl/Stdlib__Intl__RelativeTimeFormat.mjs b/src/intl/Stdlib__Intl__RelativeTimeFormat.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/intl/Stdlib__Intl__RelativeTimeFormat.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/intl/Stdlib__Intl__RelativeTimeFormat.res b/src/intl/Stdlib__Intl__RelativeTimeFormat.res index 8a56197..5443702 100644 --- a/src/intl/Stdlib__Intl__RelativeTimeFormat.res +++ b/src/intl/Stdlib__Intl__RelativeTimeFormat.res @@ -1,3 +1,4 @@ +@@uncurried type t @new external make: unit => t = "Intl.RelativeTimeFormat" diff --git a/src/typed-arrays/Stdlib__BigInt64Array.mjs b/src/typed-arrays/Stdlib__BigInt64Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__BigInt64Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__BigInt64Array.res b/src/typed-arrays/Stdlib__BigInt64Array.res index a5f548f..b7ba1f2 100644 --- a/src/typed-arrays/Stdlib__BigInt64Array.res +++ b/src/typed-arrays/Stdlib__BigInt64Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__BigUint64Array.mjs b/src/typed-arrays/Stdlib__BigUint64Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__BigUint64Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__BigUint64Array.res b/src/typed-arrays/Stdlib__BigUint64Array.res index f770d78..f36d2db 100644 --- a/src/typed-arrays/Stdlib__BigUint64Array.res +++ b/src/typed-arrays/Stdlib__BigUint64Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Float32Array.mjs b/src/typed-arrays/Stdlib__Float32Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Float32Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Float32Array.res b/src/typed-arrays/Stdlib__Float32Array.res index af74b15..c5fcba9 100644 --- a/src/typed-arrays/Stdlib__Float32Array.res +++ b/src/typed-arrays/Stdlib__Float32Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Float64Array.mjs b/src/typed-arrays/Stdlib__Float64Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Float64Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Float64Array.res b/src/typed-arrays/Stdlib__Float64Array.res index 7722f55..c060671 100644 --- a/src/typed-arrays/Stdlib__Float64Array.res +++ b/src/typed-arrays/Stdlib__Float64Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Int16Array.mjs b/src/typed-arrays/Stdlib__Int16Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Int16Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Int16Array.res b/src/typed-arrays/Stdlib__Int16Array.res index 451d43b..5b19db5 100644 --- a/src/typed-arrays/Stdlib__Int16Array.res +++ b/src/typed-arrays/Stdlib__Int16Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Int32Array.mjs b/src/typed-arrays/Stdlib__Int32Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Int32Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Int32Array.res b/src/typed-arrays/Stdlib__Int32Array.res index 8096a55..593b0c1 100644 --- a/src/typed-arrays/Stdlib__Int32Array.res +++ b/src/typed-arrays/Stdlib__Int32Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Int8Array.mjs b/src/typed-arrays/Stdlib__Int8Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Int8Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Int8Array.res b/src/typed-arrays/Stdlib__Int8Array.res index 31dd693..6d50700 100644 --- a/src/typed-arrays/Stdlib__Int8Array.res +++ b/src/typed-arrays/Stdlib__Int8Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__TypedArray.mjs b/src/typed-arrays/Stdlib__TypedArray.mjs new file mode 100644 index 0000000..d856702 --- /dev/null +++ b/src/typed-arrays/Stdlib__TypedArray.mjs @@ -0,0 +1,2 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE +/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */ diff --git a/src/typed-arrays/Stdlib__TypedArray.res b/src/typed-arrays/Stdlib__TypedArray.res index 969659c..b5a1790 100644 --- a/src/typed-arrays/Stdlib__TypedArray.res +++ b/src/typed-arrays/Stdlib__TypedArray.res @@ -1,3 +1,4 @@ +@@uncurried type t<'a> @get_index external get: (t<'a>, int) => option<'a> = "" diff --git a/src/typed-arrays/Stdlib__Uint16Array.mjs b/src/typed-arrays/Stdlib__Uint16Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Uint16Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Uint16Array.res b/src/typed-arrays/Stdlib__Uint16Array.res index 9b093d4..3a472e4 100644 --- a/src/typed-arrays/Stdlib__Uint16Array.res +++ b/src/typed-arrays/Stdlib__Uint16Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Uint32Array.mjs b/src/typed-arrays/Stdlib__Uint32Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Uint32Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Uint32Array.res b/src/typed-arrays/Stdlib__Uint32Array.res index d8b43aa..36f34a5 100644 --- a/src/typed-arrays/Stdlib__Uint32Array.res +++ b/src/typed-arrays/Stdlib__Uint32Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Uint8Array.mjs b/src/typed-arrays/Stdlib__Uint8Array.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Uint8Array.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Uint8Array.res b/src/typed-arrays/Stdlib__Uint8Array.res index d70435f..2feb636 100644 --- a/src/typed-arrays/Stdlib__Uint8Array.res +++ b/src/typed-arrays/Stdlib__Uint8Array.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/src/typed-arrays/Stdlib__Uint8ClampedArray.mjs b/src/typed-arrays/Stdlib__Uint8ClampedArray.mjs new file mode 100644 index 0000000..fd49814 --- /dev/null +++ b/src/typed-arrays/Stdlib__Uint8ClampedArray.mjs @@ -0,0 +1,9 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + + +var Constants = {}; + +export { + Constants , +} +/* No side effect */ diff --git a/src/typed-arrays/Stdlib__Uint8ClampedArray.res b/src/typed-arrays/Stdlib__Uint8ClampedArray.res index e0b4a7e..bd7ccaf 100644 --- a/src/typed-arrays/Stdlib__Uint8ClampedArray.res +++ b/src/typed-arrays/Stdlib__Uint8ClampedArray.res @@ -1,3 +1,4 @@ +@@uncurried type t = Stdlib__TypedArray.t module Constants = { diff --git a/test/TempTests.mjs b/test/TempTests.mjs new file mode 100644 index 0000000..f9fcb0d --- /dev/null +++ b/test/TempTests.mjs @@ -0,0 +1,359 @@ +// Generated by ReScript, PLEASE EDIT WITH CARE + +import * as Caml_option from "rescript/lib/es6/caml_option.js"; +import * as Stdlib__Int from "../src/Stdlib__Int.mjs"; +import * as Stdlib__Dict from "../src/Stdlib__Dict.mjs"; +import * as Stdlib__JSON from "../src/Stdlib__JSON.mjs"; +import * as Stdlib__Array from "../src/Stdlib__Array.mjs"; +import * as Stdlib__Float from "../src/Stdlib__Float.mjs"; +import * as Stdlib__BigInt from "../src/Stdlib__BigInt.mjs"; +import * as Stdlib__Option from "../src/Stdlib__Option.mjs"; +import * as Stdlib__Promise from "../src/Stdlib__Promise.mjs"; +import * as Stdlib__Undefined from "../src/Stdlib__Undefined.mjs"; + +console.info(""); + +console.info("Array"); + +console.info("---"); + +var array = [ + 1, + 2, + 3, + 4 +]; + +console.info(Stdlib__Array.reduce(array.map(function (x) { + return (x << 1); + }), 0, (function (a, b) { + return a + b | 0; + }))); + +console.info(typeof array); + +console.info(""); + +console.info("Date"); + +console.info("---"); + +var date = new Date(Date.UTC(2020, 11)); + +console.log(date.toUTCString()); + +console.info(""); + +console.info("Dict"); + +console.info("---"); + +var dict = {}; + +dict["foo"] = "bar"; + +var dict2 = Object.assign({}, dict); + +Stdlib__Dict.$$delete(dict2, "foo"); + +console.log(dict, dict2); + +console.info(""); + +console.info("Error"); + +console.info("---"); + +function f(param) { + var error = new Error("hello"); + var typeError = new TypeError("error"); + var g = function (param) { + throw error; + }; + var h = function (param) { + throw typeError; + }; + return [ + g, + h + ]; +} + +console.info(""); + +console.info("Float/Int"); + +console.info("---"); + +console.log((10.2).toFixed(2)); + +console.log((10).toFixed(2)); + +console.log(Stdlib__Int.fromString(undefined, "0")); + +console.log(Stdlib__Float.fromString("0.1")); + +console.info(""); + +console.info("Intl"); + +console.info("---"); + +var currencyFormatter = new Intl.NumberFormat("fr-FR", { + currency: "EUR", + style: "currency" + }); + +console.log(Intl.NumberFormat.supportedLocalesOf([ + "fr-FR", + "en-US" + ])); + +console.log(currencyFormatter.format(123.23)); + +console.info(""); + +console.info("JSON"); + +console.info("---"); + +var json = JSON.parse("{\"foo\": \"bar\"}"); + +var json$1 = Stdlib__JSON.Decode.classify(json); + +var tmp; + +if (typeof json$1 === "number" || json$1.TAG !== /* Object */3) { + tmp = undefined; +} else { + var value = Stdlib__JSON.Decode.classify(json$1._0["foo"]); + tmp = typeof value === "number" || value.TAG !== /* String */1 ? undefined : value._0; +} + +console.log(tmp); + +console.info(""); + +console.info("Map"); + +console.info("---"); + +var map = new Map(); + +map.set(1, 1); + +map.set(2, 2); + +map.delete(1); + +console.log(map); + +console.info(""); + +console.info("Math"); + +console.info("---"); + +console.log(Math.ceil(Math.PI / 2.0)); + +console.info(""); + +console.info("BigInt"); + +console.info("---"); + +console.log(BigInt(1) / BigInt(12.0)); + +console.info(""); + +console.info("Object"); + +console.info("---"); + +var myObject = { + foo: "bar" +}; + +console.log(Object.create(myObject)); + +console.log(Object.create(myObject, { + foo: { + value: "bar" + } + })); + +console.log(Object.create(null)); + +console.log(Object.create(null, { + foo: { + value: "bar" + } + })); + +var copy = Object.assign({}, myObject); + +var withNewProp = Object.assign(copy, { + bar: "baz" + }); + +console.info(""); + +console.info("Promise"); + +console.info("---"); + +var promise = new Promise((function (resolve, _reject) { + setTimeout((function (param) { + resolve(1); + }), 100); + })); + +Stdlib__Promise.then(Stdlib__Promise.then(Stdlib__Promise.then(promise, (function (x) { + return Promise.resolve(x + 1 | 0); + })), (function (x) { + return Promise.resolve(x + 2 | 0); + })), (function (x) { + console.log(x); + return Promise.resolve(undefined); + })).finally(function (param) { + console.log("Promise finally"); + }); + +console.info(""); + +console.info("RegExp"); + +console.info("---"); + +var regex = new RegExp("hello(\\w+)"); + +var string = "helloworld"; + +console.log(regex.test(string)); + +var result = regex.exec(string); + +var result$1 = (result == null) ? undefined : Caml_option.some(result); + +console.log(Stdlib__Option.map(result$1, (function (prim) { + return prim.input; + }))); + +console.log(Stdlib__Option.map(result$1, (function (prim) { + return prim.index; + }))); + +console.log(Stdlib__Option.map(result$1, (function (prim) { + return prim.slice(1); + }))); + +console.info(""); + +console.info("Set"); + +console.info("---"); + +var set = new Set(); + +set.add(1).add(2).delete(2); + +console.log(set); + +console.info(""); + +console.info("String"); + +console.info("---"); + +var regexp = new RegExp("(hello )(world)"); + +console.log(" Hello world ".toLowerCase().trim().replace(regexp, (function (param, group1, group2, param$1, param$2) { + return group1 + group2.toUpperCase(); + }))); + +console.info(""); + +console.info("Symbol"); + +console.info("---"); + +var x = Symbol.for("Foo"); + +console.log(x); + +var array$1 = Array.from("foo"[Symbol.iterator](undefined)); + +console.log(array$1); + +console.info(""); + +console.info("Global namespace"); + +console.info("---"); + +console.log("number"); + +var timeout = setTimeout((function (param) { + console.log("Hello!"); + }), 100); + +clearTimeout(timeout); + +if (globalThis.hello !== undefined) { + console.log(globalThis.hello.bar); + console.log("hello"); +} + +var resolvedOptions = new Intl.DateTimeFormat().resolvedOptions(); + +var timeZone = resolvedOptions.timeZone; + +var x$1 = Stdlib__Undefined.fromOption(1); + +var z = 1.2 % 1.4; + +var intFromBigInt = Stdlib__BigInt.toInt(BigInt("10000000000")); + +console.log({ + bar: "1" + }); + +var Bugfix = {}; + +console.log(Stdlib__Int.fromString(undefined, "1231231")); + +console.log(Stdlib__Int.fromString(undefined, "12.22")); + +console.log(Stdlib__Int.fromString(undefined, "99999999999999999")); + +console.log(Stdlib__Int.fromString(undefined, "99999999999999999")); + +console.log(Stdlib__Int.fromString(2, "010101")); + +export { + date , + dict , + dict2 , + f , + currencyFormatter , + json , + map , + myObject , + copy , + withNewProp , + promise , + regex , + string , + result$1 as result, + set , + regexp , + array$1 as array, + timeout , + resolvedOptions , + timeZone , + x$1 as x, + z , + intFromBigInt , + Bugfix , +} +/* Not a pure module */ diff --git a/test/TempTests.res b/test/TempTests.res index b395e43..7c3cf29 100644 --- a/test/TempTests.res +++ b/test/TempTests.res @@ -1,4 +1,5 @@ -open RescriptStdlib +@@uncurried +open ReScriptStdLib Console.info("") Console.info("Array") @@ -169,7 +170,7 @@ Console.info("Symbol") Console.info("---") let x = Symbol.getFor("Foo") Console.log(x) -let array: array = Array.fromIterator(String.getSymbolUnsafe("foo", Symbol.iterator)(.)) +let array: array = Array.fromIterator(String.getSymbolUnsafe("foo", Symbol.iterator)()) Console.log(array) Console.info("") diff --git a/yarn.lock b/yarn.lock index 1429dcb..01e85b2 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2,7 +2,6 @@ # yarn lockfile v1 -rescript@^10.1.0-rc.2: - version "10.1.0-rc.2" - resolved "https://registry.yarnpkg.com/rescript/-/rescript-10.1.0-rc.2.tgz#c24bfe853f97c0ed6556ebd388e84b76e1cf994f" - integrity sha512-CZuzCjc4gc78WBd/oEUmrz8k6hoR3DiEo6A1myJ9EkkBV97jZM92IcFSxbQJZ6SFr4bvsym4WbvNfQ0AYBXQ3g== +"rescript@file:../rescript-compiler": + "resolved" "file:../rescript-compiler" + "version" "11.0.0-alpha.1"