@@ -1,709 +0,0 @@
1−Elm.Native.Array = {};
2−Elm.Native.Array.make = function(elm) {
3− elm.Native = elm.Native || {};
4− elm.Native.Array = elm.Native.Array || {};
5− if (elm.Native.Array.values) return elm.Native.Array.values;
6− if ('values' in Elm.Native.Array)
7− return elm.Native.Array.values = Elm.Native.Array.values;
8−
9− var List = Elm.Native.List.make(elm);
10−
11− // A RRB-Tree has two distinct data types.
12− // Leaf -> "height" is always 0
13− // "table" is an array of elements
14− // Node -> "height" is always greater than 0
15− // "table" is an array of child nodes
16− // "lengths" is an array of accumulated lengths of the child nodes
17−
18− // M is the maximal table size. 32 seems fast. E is the allowed increase
19− // of search steps when concatting to find an index. Lower values will
20− // decrease balancing, but will increase search steps.
21− var M = 32;
22− var E = 2;
23−
24− // An empty array.
25− var empty = { ctor:"_Array", height:0, table:new Array() };
26−
27− function get(i, array) {
28− if (i < 0 || i >= length(array)) {
29− throw new Error("Index " + i + " is out of range. Check the length of " +
30− "your array first or use getMaybe or getWithDefault.");
31− }
32− return unsafeGet(i, array);
33− }
34−
35− function unsafeGet(i, array) {
36− for (var x = array.height; x > 0; x--) {
37− var slot = i >> (x * 5);
38− while (array.lengths[slot] <= i) {
39− slot++;
40− }
41− if (slot > 0) {
42− i -= array.lengths[slot - 1];
43− }
44− array = array.table[slot];
45− }
46− return array.table[i];
47− }
48−
49− // Sets the value at the index i. Only the nodes leading to i will get
50− // copied and updated.
51− function set(i, item, array) {
52− if (i < 0 || length(array) <= i) {
53− return array;
54− }
55− return unsafeSet(i, item, array);
56− }
57−
58− function unsafeSet(i, item, array) {
59− array = nodeCopy(array);
60−
61− if (array.height == 0) {
62− array.table[i] = item;
63− } else {
64− var slot = getSlot(i, array);
65− if (slot > 0) {
66− i -= array.lengths[slot - 1];
67− }
68− array.table[slot] = unsafeSet(i, item, array.table[slot]);
69− }
70− return array;
71− }
72−
73− function initialize(len, f) {
74− if (len == 0) { return empty; }
75− var h = Math.floor(Math.log(len)/Math.log(M));
76− return initialize_(f, h, 0, len);
77− }
78−
79− function initialize_(f, h, from, to) {
80− if (h == 0) {
81− var table = new Array((to - from) % (M + 1));
82− for (var i = 0; i < table.length; i++) {
83− table[i] = f(from + i);
84− }
85− return { ctor:"_Array", height:0, table:table };
86− }
87−
88− var step = Math.pow(M, h);
89− var table = new Array(Math.ceil((to - from) / step));
90− var lengths = new Array(table.length);
91− for (var i = 0; i < table.length; i++) {
92− table[i] = initialize_( f, h - 1, from + (i * step)
93− , Math.min(from + ((i + 1) * step), to));
94− lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
95− }
96− return { ctor:"_Array", height:h, table:table, lengths:lengths };
97− }
98−
99− function fromList(list) {
100− if (list == List.Nil) { return empty; }
101−
102− // Allocate M sized blocks (table) and write list elements to it.
103− var table = new Array(M);
104− var nodes = new Array();
105− var i = 0;
106−
107− while (list.ctor !== '[]') {
108− table[i] = list._0;
109− list = list._1;
110− i++;
111−
112− // table is full, so we can push a leaf containing it into the
113− // next node.
114− if (i == M) {
115− fromListPush({ ctor:"_Array", height:0, table:table }
116− , nodes);
117− table = new Array(M);
118− i = 0;
119− }
120− }
121−
122− // Maybe there is something left on the table.
123− if (i > 0) {
124− fromListPush({ ctor:"_Array", height:0, table:table.splice(0,i) }
125− , nodes);
126− }
127−
128− // Go through all of the nodes and eventually push them into higher nodes.
129− for (var h = 0; h < nodes.length - 1; h++) {
130− if (nodes[h].table.length > 0) {
131− fromListPush(nodes[h], nodes);
132− }
133− }
134−
135− var head = nodes[nodes.length - 1];
136− if (head.height > 0 && head.table.length == 1) {
137− return head.table[0];
138− } else {
139− return head;
140− }
141− }
142−
143− // Push a node into a higher node as a child.
144− function fromListPush(toPush, nodes) {
145− var h = toPush.height;
146−
147− // Maybe the node on this height does not exist.
148− if (nodes.length == h) {
149− nodes.push({ ctor:"_Array", height:h + 1
150− , table:new Array()
151− , lengths:new Array() });
152− }
153−
154− nodes[h].table.push(toPush);
155− var len = length(toPush);
156− if (nodes[h].lengths.length > 0) {
157− len += nodes[h].lengths[nodes[h].lengths.length - 1];
158− }
159− nodes[h].lengths.push(len);
160−
161− if (nodes[h].table.length == M) {
162− fromListPush(nodes[h], nodes);
163− nodes[h] = { ctor:"_Array", height:h + 1
164− , table:new Array()
165− , lengths:new Array() };
166− }
167− }
168−
169− // Pushes an item via push_ to the bottom right of a tree.
170− function push(item, a) {
171− var pushed = push_(item, a);
172− if (pushed !== null) {
173− return pushed;
174− }
175−
176− var newTree = create(item, a.height);
177− return siblise(a, newTree);
178− }
179−
180− // Recursively tries to push an item to the bottom-right most
181− // tree possible. If there is no space left for the item,
182− // null will be returned.
183− function push_(item, a) {
184− // Handle resursion stop at leaf level.
185− if (a.height == 0) {
186− if (a.table.length < M) {
187− var newA = { ctor:"_Array", height:0, table:a.table.slice() };
188− newA.table.push(item);
189− return newA;
190− } else {
191− return null;
192− }
193− }
194−
195− // Recursively push
196− var pushed = push_(item, botRight(a));
197−
198− // There was space in the bottom right tree, so the slot will
199− // be updated.
200− if (pushed != null) {
201− var newA = nodeCopy(a);
202− newA.table[newA.table.length - 1] = pushed;
203− newA.lengths[newA.lengths.length - 1]++;
204− return newA
205− }
206−
207− // When there was no space left, check if there is space left
208− // for a new slot with a tree which contains only the item
209− // at the bottom.
210− if (a.table.length < M) {
211− var newSlot = create(item, a.height - 1);
212− var newA = nodeCopy(a);
213− newA.table.push(newSlot);
214− newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
215− return newA
216− } else {
217− return null;
218− }
219− }
220−
221− // Converts an array into a list of elements.
222− function toList(a) {
223− return toList_(List.Nil, a);
224− }
225−
226− function toList_(list, a) {
227− for (var i = a.table.length - 1; i >= 0; i--) {
228− list = a.height == 0 ? List.Cons(a.table[i], list) : toList_(list, a.table[i]);
229− }
230− return list;
231− }
232−
233− // Maps a function over the elements of an array.
234− function map(f, a) {
235− var newA = { ctor:"_Array", height:a.height, table:new Array(a.table) };
236− if (a.height > 0) { newA.lengths = a.lengths; }
237− for (var i = 0; i < a.table.length; i++) {
238− newA.table[i] = a.height == 0 ? f(a.table[i]) : map(f, a.table[i]);
239− }
240− return newA;
241− }
242−
243− // Maps a function over the elements with their index as first argument.
244− function indexedMap(f, a) {
245− return indexedMap_(f, a, 0);
246− }
247−
248− function indexedMap_(f, a, from) {
249− var newA = { ctor:"_Array", height:a.height, table:new Array(a.table) };
250− if (a.height > 0) { newA.lengths = a.lengths; }
251− for (var i = 0; i < a.table.length; i++) {
252− newA.table[i] = a.height == 0 ? A2(f, from + i, a.table[i])
253− : indexedMap_( f, a.table[i]
254− , i == 0 ? 0 : a.lengths[i - 1]);
255− }
256− return newA;
257− }
258−
259− function foldl(f, b, a) {
260− if (a.height == 0) {
261− for (var i = 0; i < a.table.length; i++) {
262− b = A2(f, a.table[i], b);
263− }
264− } else {
265− for (var i = 0; i < a.table.length; i++) {
266− b = foldl(f, b, a.table[i]);
267− }
268− }
269− return b;
270− }
271−
272− function foldr(f, b, a) {
273− if (a.height == 0) {
274− for (var i = a.table.length; i--; ) {
275− b = A2(f, a.table[i], b);
276− }
277− } else {
278− for (var i = a.table.length; i--; ) {
279− b = foldl(f, b, a.table[i]);
280− }
281− }
282− return b;
283− }
284−
285− // TODO: currently, it slices the right, then the left. This can be
286− // optimized.
287− function slice(from, to, a) {
288− if (from < 0) { from += length(a); }
289− if (to < 0) { to += length(a); }
290− return sliceLeft(from, sliceRight(to, a));
291− }
292−
293− function sliceRight(to, a) {
294− if (to == length(a)) {
295− return a;
296− }
297−
298− // Handle leaf level.
299− if (a.height == 0) {
300− var newA = { ctor:"_Array", height:0 };
301− newA.table = a.table.slice(0, to);
302− return newA;
303− }
304−
305− // Slice the right recursively.
306− var right = getSlot(to, a);
307− var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);
308−
309− // Maybe the a node is not even needed, as sliced contains the whole slice.
310− if (right == 0) {
311− return sliced;
312− }
313−
314− // Create new node.
315− var newA = { ctor:"_Array", height:a.height
316− , table:a.table.slice(0, right)
317− , lengths:a.lengths.slice(0, right) };
318− if (sliced.table.length > 0) {
319− newA.table[right] = sliced;
320− newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
321− }
322− return newA;
323− }
324−
325− function sliceLeft(from, a) {
326− if (from == 0) {
327− return a;
328− }
329−
330− // Handle leaf level.
331− if (a.height == 0) {
332− var newA = { ctor:"_Array", height:0 };
333− newA.table = a.table.slice(from, a.table.length + 1);
334− return newA;
335− }
336−
337− // Slice the left recursively.
338− var left = getSlot(from, a);
339− var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);
340−
341− // Maybe the a node is not even needed, as sliced contains the whole slice.
342− if (left == a.table.length - 1) {
343− return sliced;
344− }
345−
346− // Create new node.
347− var newA = { ctor:"_Array", height:a.height
348− , table:a.table.slice(left, a.table.length + 1)
349− , lengths:new Array(a.table.length - left) };
350− newA.table[0] = sliced;
351− var len = 0;
352− for (var i = 0; i < newA.table.length; i++) {
353− len += length(newA.table[i]);
354− newA.lengths[i] = len;
355− }
356−
357− return newA;
358− }
359−
360− // Appends two trees.
361− function append(a,b) {
362− if (a.table.length === 0) {
363− return b;
364− }
365− if (b.table.length === 0) {
366− return a;
367− }
368−
369− var c = append_(a, b);
370−
371− // Check if both nodes can be crunshed together.
372− if (c[0].table.length + c[1].table.length <= M) {
373− if (c[0].table.length === 0) {
374− return c[1];
375− }
376− if (c[1].table.length === 0) {
377− return c[0];
378− }
379−
380− // Adjust .table and .lengths
381− c[0].table = c[0].table.concat(c[1].table);
382− if (c[0].height > 0) {
383− var len = length(c[0]);
384− for (var i = 0; i < c[1].lengths.length; i++) {
385− c[1].lengths[i] += len;
386− }
387− c[0].lengths = c[0].lengths.concat(c[1].lengths);
388− }
389−
390− return c[0];
391− }
392−
393− var toRemove = calcToRemove(a, b);
394− if (toRemove > E) {
395− c = shuffle(c[0], c[1], toRemove);
396− }
397−
398− return siblise(c[0], c[1]);
399− }
400−
401− // Returns an array of two nodes; right and left. One node _may_ be empty.
402− function append_(a, b) {
403− if (a.height === 0 && b.height === 0) {
404− return [a, b];
405− }
406−
407− if (a.height !== 1 || b.height !== 1) {
408− if (a.height === b.height) {
409− a = nodeCopy(a);
410− b = nodeCopy(b);
411− var appended = append_(botRight(a), botLeft(b));
412−
413− insertRight(a, appended[1]);
414− insertLeft(b, appended[0]);
415− } else if (a.height > b.height) {
416− a = nodeCopy(a);
417− var appended = append_(botRight(a), b);
418−
419− insertRight(a, appended[0]);
420− b = parentise(appended[1], appended[1].height + 1);
421− } else {
422− b = nodeCopy(b);
423− var appended = append_(a, botLeft(b));
424−
425− var left = appended[0].table.length === 0 ? 0 : 1;
426− var right = left === 0 ? 1 : 0;
427− insertLeft(b, appended[left]);
428− a = parentise(appended[right], appended[right].height + 1);
429− }
430− }
431−
432− // Check if balancing is needed and return based on that.
433− if (a.table.length === 0 || b.table.length === 0) {
434− return [a,b];
435− }
436−
437− var toRemove = calcToRemove(a, b);
438− if (toRemove <= E) {
439− return [a,b];
440− }
441− return shuffle(a, b, toRemove);
442− }
443−
444− // Helperfunctions for append_. Replaces a child node at the side of the parent.
445− function insertRight(parent, node) {
446− var index = parent.table.length - 1;
447− parent.table[index] = node;
448− parent.lengths[index] = length(node)
449− parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
450− }
451−
452− function insertLeft(parent, node) {
453− if (node.table.length > 0) {
454− parent.table[0] = node;
455− parent.lengths[0] = length(node);
456−
457− var len = length(parent.table[0]);
458− for (var i = 1; i < parent.lengths.length; i++) {
459− len += length(parent.table[i]);
460− parent.lengths[i] = len;
461− }
462− } else {
463− parent.table.shift();
464− for (var i = 1; i < parent.lengths.length; i++) {
465− parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
466− }
467− parent.lengths.shift();
468− }
469− }
470−
471− // Returns the extra search steps for E. Refer to the paper.
472− function calcToRemove(a, b) {
473− var subLengths = 0;
474− for (var i = 0; i < a.table.length; i++) {
475− subLengths += a.table[i].table.length;
476− }
477− for (var i = 0; i < b.table.length; i++) {
478− subLengths += b.table[i].table.length;
479− }
480−
481− var toRemove = a.table.length + b.table.length
482− return toRemove - (Math.floor((subLengths - 1) / M) + 1);
483− }
484−
485− // get2, set2 and saveSlot are helpers for accessing elements over two arrays.
486− function get2(a, b, index) {
487− return index < a.length ? a[index] : b[index - a.length];
488− }
489−
490− function set2(a, b, index, value) {
491− if (index < a.length) {
492− a[index] = value;
493− } else {
494− b[index - a.length] = value;
495− }
496− }
497−
498− function saveSlot(a, b, index, slot) {
499− set2(a.table, b.table, index, slot);
500−
501− var l = (index == 0 || index == a.lengths.length) ?
502− 0 : get2(a.lengths, a.lengths, index - 1);
503− set2(a.lengths, b.lengths, index, l + length(slot));
504− }
505−
506− // Creates a node or leaf with a given length at their arrays for perfomance.
507− // Is only used by shuffle.
508− function createNode(h, length) {
509− if (length < 0) { length = 0; }
510− var a = { ctor:"_Array", height:h, table:new Array(length) };
511− if (h > 0) {
512− a.lengths = new Array(length);
513− }
514− return a;
515− }
516−
517− // Returns an array of two balanced nodes.
518− function shuffle(a, b, toRemove) {
519− var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
520− var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));
521−
522− // Skip the slots with size M. More precise: copy the slot references
523− // to the new node
524− var read = 0;
525− while (get2(a.table, b.table, read).table.length % M == 0) {
526− set2(newA.table, newB.table, read, get2(a.table, b.table, read));
527− set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
528− read++;
529− }
530−
531− // Pulling items from left to right, caching in a slot before writing
532− // it into the new nodes.
533− var write = read;
534− var slot = new createNode(a.height - 1, 0);
535− var from = 0;
536−
537− // If the current slot is still containing data, then there will be at
538− // least one more write, so we do not break this loop yet.
539− while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove) {
540− // Find out the max possible items for copying.
541− var source = get2(a.table, b.table, read);
542− var to = Math.min(M - slot.table.length, source.table.length)
543−
544− // Copy and adjust size table.
545− slot.table = slot.table.concat(source.table.slice(from, to));
546− if (slot.height > 0) {
547− var len = slot.lengths.length;
548− for (var i = len; i < len + to - from; i++) {
549− slot.lengths[i] = length(slot.table[i]);
550− slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
551− }
552− }
553−
554− from += to;
555−
556− // Only proceed to next slots[i] if the current one was
557− // fully copied.
558− if (source.table.length <= to) {
559− read++; from = 0;
560− }
561−
562− // Only create a new slot if the current one is filled up.
563− if (slot.table.length == M) {
564− saveSlot(newA, newB, write, slot);
565− slot = createNode(a.height - 1,0);
566− write++;
567− }
568− }
569−
570− // Cleanup after the loop. Copy the last slot into the new nodes.
571− if (slot.table.length > 0) {
572− saveSlot(newA, newB, write, slot);
573− write++;
574− }
575−
576− // Shift the untouched slots to the left
577− while (read < a.table.length + b.table.length ) {
578− saveSlot(newA, newB, write, get2(a.table, b.table, read));
579− read++; write++;
580− }
581−
582− return [newA, newB];
583− }
584−
585− // Navigation functions
586− function botRight(a) { return a.table[a.table.length - 1]; }
587− function botLeft(a) { return a.table[0]; }
588−
589− // Copies a node for updating. Note that you should not use this if
590− // only updating only one of "table" or "lengths" for performance reasons.
591− function nodeCopy(a) {
592− var newA = { ctor:"_Array", height:a.height
593− , table:a.table.slice() };
594− if (a.height > 0) { newA.lengths = a.lengths.slice(); }
595− return newA;
596− }
597−
598− // Returns how many items are in the tree.
599− function length(array) {
600− if (array.height == 0) {
601− return array.table.length;
602− } else {
603− return array.lengths[array.lengths.length - 1];
604− }
605− }
606−
607− // Calculates in which slot of "table" the item probably is, then
608− // find the exact slot via forward searching in "lengths". Returns the index.
609− function getSlot(i, a) {
610− var slot = i >> (5 * a.height);
611− while (a.lengths[slot] <= i) {
612− slot++;
613− }
614− return slot;
615− }
616−
617− // Recursively creates a tree with a given height containing
618− // only the given item.
619− function create(item, h) {
620− if (h == 0) {
621− return { ctor:"_Array", height:0
622− , table:[item] };
623− } else {
624− return { ctor:"_Array", height:h
625− , table:[create(item, h - 1)]
626− , lengths:[1] };
627− }
628− }
629−
630− // Recursively creates a tree that contains the given tree.
631− function parentise(tree, h) {
632− if (h == tree.height) {
633− return tree;
634− } else {
635− return { ctor:"_Array", height:h
636− , table:[parentise(tree, h - 1)]
637− , lengths:[length(tree)] };
638− }
639− }
640−
641− // Emphasizes blood brotherhood beneath two trees.
642− function siblise(a, b) {
643− return { ctor:"_Array", height:a.height + 1
644− , table:[a, b]
645− , lengths:[length(a), length(a) + length(b)] };
646− }
647−
648− function toJSArray(a) {
649− var jsArray = new Array(length(a));
650− toJSArray_(jsArray, 0, a);
651− return jsArray;
652− }
653−
654− function toJSArray_(jsArray, i, a) {
655− for (var t = 0; t < a.table.length; t++) {
656− if (a.height == 0) {
657− jsArray[i + t] = a.table[t];
658− } else {
659− var inc = t == 0 ? 0 : a.lengths[t - 1];
660− toJSArray_(jsArray, i + inc, a.table[t]);
661− }
662− }
663− }
664−
665− function fromJSArray(jsArray) {
666− if (jsArray.length == 0) { return empty; }
667− var h = Math.floor(Math.log(jsArray.length) / Math.log(M));
668− return fromJSArray_(jsArray, h, 0, jsArray.length);
669− }
670−
671− function fromJSArray_(jsArray, h, from, to) {
672− if (h == 0) {
673− return { ctor:"_Array", height:0
674− , table:jsArray.slice(from, to) };
675− }
676−
677− var step = Math.pow(M, h);
678− var table = new Array(Math.ceil((to - from) / step));
679− var lengths = new Array(table.length);
680− for (var i = 0; i < table.length; i++) {
681− table[i] = fromJSArray_( jsArray, h - 1, from + (i * step)
682− , Math.min(from + ((i + 1) * step), to));
683− lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
684− }
685− return { ctor:"_Array", height:h, table:table, lengths:lengths };
686− }
687−
688− Elm.Native.Array.values = {
689− empty:empty,
690− fromList:fromList,
691− toList:toList,
692− initialize:F2(initialize),
693− append:F2(append),
694− push:F2(push),
695− slice:F3(slice),
696− get:F2(get),
697− set:F3(set),
698− map:F2(map),
699− indexedMap:F2(indexedMap),
700− foldl:F3(foldl),
701− foldr:F3(foldr),
702− length:length,
703−
704− toJSArray:toJSArray,
705− fromJSArray:fromJSArray
706− };
707−
708− return elm.Native.Array.values = Elm.Native.Array.values;
709−}