git.iko.soy/rowtype-yoga/yoga-r3f
on main help sign in
rowtype-yoga/yoga-r3f/output/Data.Array/foreign.js
298 lines 8.0 kB history raw
1//------------------------------------------------------------------------------
2// Array creation --------------------------------------------------------------
3//------------------------------------------------------------------------------
5export const rangeImpl = function (start, end) {
6 var step = start > end ? -1 : 1;
7 var result = new Array(step * (end - start) + 1);
8 var i = start, n = 0;
9 while (i !== end) {
10 result[n++] = i;
11 i += step;
12 }
13 result[n] = i;
14 return result;
15};
17var replicateFill = function (count, value) {
18 if (count < 1) {
19 return [];
20 }
21 var result = new Array(count);
22 return result.fill(value);
23};
25var replicatePolyfill = function (count, value) {
26 var result = [];
27 var n = 0;
28 for (var i = 0; i < count; i++) {
29 result[n++] = value;
30 }
31 return result;
32};
34// In browsers that have Array.prototype.fill we use it, as it's faster.
35export const replicateImpl = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
37export const fromFoldableImpl = (function () {
38 function Cons(head, tail) {
39 this.head = head;
40 this.tail = tail;
41 }
42 var emptyList = {};
44 function curryCons(head) {
45 return function (tail) {
46 return new Cons(head, tail);
47 };
48 }
50 function listToArray(list) {
51 var result = [];
52 var count = 0;
53 var xs = list;
54 while (xs !== emptyList) {
55 result[count++] = xs.head;
56 xs = xs.tail;
57 }
58 return result;
59 }
61 return function (foldr, xs) {
62 return listToArray(foldr(curryCons)(emptyList)(xs));
63 };
64})();
66//------------------------------------------------------------------------------
67// Array size ------------------------------------------------------------------
68//------------------------------------------------------------------------------
70export const length = function (xs) {
71 return xs.length;
72};
74//------------------------------------------------------------------------------
75// Non-indexed reads -----------------------------------------------------------
76//------------------------------------------------------------------------------
78export const unconsImpl = function (empty, next, xs) {
79 return xs.length === 0 ? empty({}) : next(xs[0])(xs.slice(1));
80};
82//------------------------------------------------------------------------------
83// Indexed operations ----------------------------------------------------------
84//------------------------------------------------------------------------------
86export const indexImpl = function (just, nothing, xs, i) {
87 return i < 0 || i >= xs.length ? nothing : just(xs[i]);
88};
90export const findMapImpl = function (nothing, isJust, f, xs) {
91 for (var i = 0; i < xs.length; i++) {
92 var result = f(xs[i]);
93 if (isJust(result)) return result;
94 }
95 return nothing;
96};
98export const findIndexImpl = function (just, nothing, f, xs) {
99 for (var i = 0, l = xs.length; i < l; i++) {
100 if (f(xs[i])) return just(i);
101 }
102 return nothing;
103};
105export const findLastIndexImpl = function (just, nothing, f, xs) {
106 for (var i = xs.length - 1; i >= 0; i--) {
107 if (f(xs[i])) return just(i);
108 }
109 return nothing;
110};
112export const _insertAt = function (just, nothing, i, a, l) {
113 if (i < 0 || i > l.length) return nothing;
114 var l1 = l.slice();
115 l1.splice(i, 0, a);
116 return just(l1);
117};
119export const _deleteAt = function (just, nothing, i, l) {
120 if (i < 0 || i >= l.length) return nothing;
121 var l1 = l.slice();
122 l1.splice(i, 1);
123 return just(l1);
124};
126export const _updateAt = function (just, nothing, i, a, l) {
127 if (i < 0 || i >= l.length) return nothing;
128 var l1 = l.slice();
129 l1[i] = a;
130 return just(l1);
131};
133//------------------------------------------------------------------------------
134// Transformations -------------------------------------------------------------
135//------------------------------------------------------------------------------
137export const reverse = function (l) {
138 return l.slice().reverse();
139};
141export const concat = function (xss) {
142 if (xss.length <= 10000) {
143 // This method is faster, but it crashes on big arrays.
144 // So we use it when can and fallback to simple variant otherwise.
145 return Array.prototype.concat.apply([], xss);
146 }
148 var result = [];
149 for (var i = 0, l = xss.length; i < l; i++) {
150 var xs = xss[i];
151 for (var j = 0, m = xs.length; j < m; j++) {
152 result.push(xs[j]);
153 }
154 }
155 return result;
156};
158export const filterImpl = function (f, xs) {
159 return xs.filter(f);
160};
162export const partitionImpl = function (f, xs) {
163 var yes = [];
164 var no = [];
165 for (var i = 0; i < xs.length; i++) {
166 var x = xs[i];
167 if (f(x))
168 yes.push(x);
169 else
170 no.push(x);
171 }
172 return { yes: yes, no: no };
173};
175export const scanlImpl = function (f, b, xs) {
176 var len = xs.length;
177 var acc = b;
178 var out = new Array(len);
179 for (var i = 0; i < len; i++) {
180 acc = f(acc)(xs[i]);
181 out[i] = acc;
182 }
183 return out;
184};
186export const scanrImpl = function (f, b, xs) {
187 var len = xs.length;
188 var acc = b;
189 var out = new Array(len);
190 for (var i = len - 1; i >= 0; i--) {
191 acc = f(xs[i])(acc);
192 out[i] = acc;
193 }
194 return out;
195};
197//------------------------------------------------------------------------------
198// Sorting ---------------------------------------------------------------------
199//------------------------------------------------------------------------------
201export const sortByImpl = (function () {
202 function mergeFromTo(compare, fromOrdering, xs1, xs2, from, to) {
203 var mid;
204 var i;
205 var j;
206 var k;
207 var x;
208 var y;
209 var c;
211 mid = from + ((to - from) >> 1);
212 if (mid - from > 1) mergeFromTo(compare, fromOrdering, xs2, xs1, from, mid);
213 if (to - mid > 1) mergeFromTo(compare, fromOrdering, xs2, xs1, mid, to);
215 i = from;
216 j = mid;
217 k = from;
218 while (i < mid && j < to) {
219 x = xs2[i];
220 y = xs2[j];
221 c = fromOrdering(compare(x)(y));
222 if (c > 0) {
223 xs1[k++] = y;
224 ++j;
225 }
226 else {
227 xs1[k++] = x;
228 ++i;
229 }
230 }
231 while (i < mid) {
232 xs1[k++] = xs2[i++];
233 }
234 while (j < to) {
235 xs1[k++] = xs2[j++];
236 }
237 }
239 return function (compare, fromOrdering, xs) {
240 var out;
242 if (xs.length < 2) return xs;
244 out = xs.slice(0);
245 mergeFromTo(compare, fromOrdering, out, xs.slice(0), 0, xs.length);
247 return out;
248 };
249})();
251//------------------------------------------------------------------------------
252// Subarrays -------------------------------------------------------------------
253//------------------------------------------------------------------------------
255export const sliceImpl = function (s, e, l) {
256 return l.slice(s, e);
257};
259//------------------------------------------------------------------------------
260// Zipping ---------------------------------------------------------------------
261//------------------------------------------------------------------------------
263export const zipWithImpl = function (f, xs, ys) {
264 var l = xs.length < ys.length ? xs.length : ys.length;
265 var result = new Array(l);
266 for (var i = 0; i < l; i++) {
267 result[i] = f(xs[i])(ys[i]);
268 }
269 return result;
270};
272//------------------------------------------------------------------------------
273// Folding ---------------------------------------------------------------------
274//------------------------------------------------------------------------------
276export const anyImpl = function (p, xs) {
277 var len = xs.length;
278 for (var i = 0; i < len; i++) {
279 if (p(xs[i])) return true;
280 }
281 return false;
282};
284export const allImpl = function (p, xs) {
285 var len = xs.length;
286 for (var i = 0; i < len; i++) {
287 if (!p(xs[i])) return false;
288 }
289 return true;
290};
292//------------------------------------------------------------------------------
293// Partial ---------------------------------------------------------------------
294//------------------------------------------------------------------------------
296export const unsafeIndexImpl = function (xs, n) {
297 return xs[n];
298};