mochikit_v14/MochiKit/Iter.js

   1 /***
   2
   3 MochiKit.Iter 1.4
   4
   5 See <http://mochikit.com/> for documentation, downloads, license, etc.
   6
   7 (c) 2005 Bob Ippolito.  All rights Reserved.
   8
   9 ***/
  10
  11 if (typeof(dojo) != 'undefined') {
  12     dojo.provide('MochiKit.Iter');
  13     dojo.require('MochiKit.Base');
  14 }
  15
  16 if (typeof(JSAN) != 'undefined') {
  17     JSAN.use("MochiKit.Base", []);
  18 }
  19
  20 try {
  21     if (typeof(MochiKit.Base) == 'undefined') {
  22         throw "";
  23     }
  24 } catch (e) {
  25     throw "MochiKit.Iter depends on MochiKit.Base!";
  26 }
  27
  28 if (typeof(MochiKit.Iter) == 'undefined') {
  29     MochiKit.Iter = {};
  30 }
  31
  32 MochiKit.Iter.NAME = "MochiKit.Iter";
  33 MochiKit.Iter.VERSION = "1.4";
  34 MochiKit.Base.update(MochiKit.Iter, {
  35     __repr__: function () {
  36         return "[" + this.NAME + " " + this.VERSION + "]";
  37     },
  38     toString: function () {
  39         return this.__repr__();
  40     },
  41
  42     /** @id MochiKit.Iter.registerIteratorFactory  */
  43     registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) {
  44         MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override);
  45     },
  46
  47     /** @id MochiKit.Iter.iter */
  48     iter: function (iterable, /* optional */ sentinel) {
  49         var self = MochiKit.Iter;
  50         if (arguments.length == 2) {
  51             return self.takewhile(
  52                 function (a) { return a != sentinel; },
  53                 iterable
  54             );
  55         }
  56         if (typeof(iterable.next) == 'function') {
  57             return iterable;
  58         } else if (typeof(iterable.iter) == 'function') {
  59             return iterable.iter();
  60         /*
  61         }  else if (typeof(iterable.__iterator__) == 'function') {
  62             //
  63             // XXX: We can't support JavaScript 1.7 __iterator__ directly
  64             //      because of Object.prototype.__iterator__
  65             //
  66             return iterable.__iterator__();
  67         */
  68         }
  69
  70         try {
  71             return self.iteratorRegistry.match(iterable);
  72         } catch (e) {
  73             var m = MochiKit.Base;
  74             if (e == m.NotFound) {
  75                 e = new TypeError(typeof(iterable) + ": " + m.repr(iterable) + " is not iterable");
  76             }
  77             throw e;
  78         }
  79     },
  80
  81     /** @id MochiKit.Iter.count */
  82     count: function (n) {
  83         if (!n) {
  84             n = 0;
  85         }
  86         var m = MochiKit.Base;
  87         return {
  88             repr: function () { return "count(" + n + ")"; },
  89             toString: m.forwardCall("repr"),
  90             next: m.counter(n)
  91         };
  92     },
  93
  94     /** @id MochiKit.Iter.cycle */
  95     cycle: function (p) {
  96         var self = MochiKit.Iter;
  97         var m = MochiKit.Base;
  98         var lst = [];
  99         var iterator = self.iter(p);
 100         return {
 101             repr: function () { return "cycle(...)"; },
 102             toString: m.forwardCall("repr"),
 103             next: function () {
 104                 try {
 105                     var rval = iterator.next();
 106                     lst.push(rval);
 107                     return rval;
 108                 } catch (e) {
 109                     if (e != self.StopIteration) {
 110                         throw e;
 111                     }
 112                     if (lst.length === 0) {
 113                         this.next = function () {
 114                             throw self.StopIteration;
 115                         };
 116                     } else {
 117                         var i = -1;
 118                         this.next = function () {
 119                             i = (i + 1) % lst.length;
 120                             return lst[i];
 121                         };
 122                     }
 123                     return this.next();
 124                 }
 125             }
 126         };
 127     },
 128
 129     /** @id MochiKit.Iter.repeat */
 130     repeat: function (elem, /* optional */n) {
 131         var m = MochiKit.Base;
 132         if (typeof(n) == 'undefined') {
 133             return {
 134                 repr: function () {
 135                     return "repeat(" + m.repr(elem) + ")";
 136                 },
 137                 toString: m.forwardCall("repr"),
 138                 next: function () {
 139                     return elem;
 140                 }
 141             };
 142         }
 143         return {
 144             repr: function () {
 145                 return "repeat(" + m.repr(elem) + ", " + n + ")";
 146             },
 147             toString: m.forwardCall("repr"),
 148             next: function () {
 149                 if (n <= 0) {
 150                     throw MochiKit.Iter.StopIteration;
 151                 }
 152                 n -= 1;
 153                 return elem;
 154             }
 155         };
 156     },
 157
 158     /** @id MochiKit.Iter.next */
 159     next: function (iterator) {
 160         return iterator.next();
 161     },
 162
 163     /** @id MochiKit.Iter.izip */
 164     izip: function (p, q/*, ...*/) {
 165         var m = MochiKit.Base;
 166         var self = MochiKit.Iter;
 167         var next = self.next;
 168         var iterables = m.map(self.iter, arguments);
 169         return {
 170             repr: function () { return "izip(...)"; },
 171             toString: m.forwardCall("repr"),
 172             next: function () { return m.map(next, iterables); }
 173         };
 174     },
 175
 176     /** @id MochiKit.Iter.ifilter */
 177     ifilter: function (pred, seq) {
 178         var m = MochiKit.Base;
 179         seq = MochiKit.Iter.iter(seq);
 180         if (pred === null) {
 181             pred = m.operator.truth;
 182         }
 183         return {
 184             repr: function () { return "ifilter(...)"; },
 185             toString: m.forwardCall("repr"),
 186             next: function () {
 187                 while (true) {
 188                     var rval = seq.next();
 189                     if (pred(rval)) {
 190                         return rval;
 191                     }
 192                 }
 193                 // mozilla warnings aren't too bright
 194                 return undefined;
 195             }
 196         };
 197     },
 198
 199     /** @id MochiKit.Iter.ifilterfalse */
 200     ifilterfalse: function (pred, seq) {
 201         var m = MochiKit.Base;
 202         seq = MochiKit.Iter.iter(seq);
 203         if (pred === null) {
 204             pred = m.operator.truth;
 205         }
 206         return {
 207             repr: function () { return "ifilterfalse(...)"; },
 208             toString: m.forwardCall("repr"),
 209             next: function () {
 210                 while (true) {
 211                     var rval = seq.next();
 212                     if (!pred(rval)) {
 213                         return rval;
 214                     }
 215                 }
 216                 // mozilla warnings aren't too bright
 217                 return undefined;
 218             }
 219         };
 220     },
 221
 222     /** @id MochiKit.Iter.islice */
 223     islice: function (seq/*, [start,] stop[, step] */) {
 224         var self = MochiKit.Iter;
 225         var m = MochiKit.Base;
 226         seq = self.iter(seq);
 227         var start = 0;
 228         var stop = 0;
 229         var step = 1;
 230         var i = -1;
 231         if (arguments.length == 2) {
 232             stop = arguments[1];
 233         } else if (arguments.length == 3) {
 234             start = arguments[1];
 235             stop = arguments[2];
 236         } else {
 237             start = arguments[1];
 238             stop = arguments[2];
 239             step = arguments[3];
 240         }
 241         return {
 242             repr: function () {
 243                 return "islice(" + ["...", start, stop, step].join(", ") + ")";
 244             },
 245             toString: m.forwardCall("repr"),
 246             next: function () {
 247                 var rval;
 248                 while (i < start) {
 249                     rval = seq.next();
 250                     i++;
 251                 }
 252                 if (start >= stop) {
 253                     throw self.StopIteration;
 254                 }
 255                 start += step;
 256                 return rval;
 257             }
 258         };
 259     },
 260
 261     /** @id MochiKit.Iter.imap */
 262     imap: function (fun, p, q/*, ...*/) {
 263         var m = MochiKit.Base;
 264         var self = MochiKit.Iter;
 265         var iterables = m.map(self.iter, m.extend(null, arguments, 1));
 266         var map = m.map;
 267         var next = self.next;
 268         return {
 269             repr: function () { return "imap(...)"; },
 270             toString: m.forwardCall("repr"),
 271             next: function () {
 272                 return fun.apply(this, map(next, iterables));
 273             }
 274         };
 275     },
 276
 277     /** @id MochiKit.Iter.applymap */
 278     applymap: function (fun, seq, self) {
 279         seq = MochiKit.Iter.iter(seq);
 280         var m = MochiKit.Base;
 281         return {
 282             repr: function () { return "applymap(...)"; },
 283             toString: m.forwardCall("repr"),
 284             next: function () {
 285                 return fun.apply(self, seq.next());
 286             }
 287         };
 288     },
 289
 290     /** @id MochiKit.Iter.chain */
 291     chain: function (p, q/*, ...*/) {
 292         // dumb fast path
 293         var self = MochiKit.Iter;
 294         var m = MochiKit.Base;
 295         if (arguments.length == 1) {
 296             return self.iter(arguments[0]);
 297         }
 298         var argiter = m.map(self.iter, arguments);
 299         return {
 300             repr: function () { return "chain(...)"; },
 301             toString: m.forwardCall("repr"),
 302             next: function () {
 303                 while (argiter.length > 1) {
 304                     try {
 305                         return argiter[0].next();
 306                     } catch (e) {
 307                         if (e != self.StopIteration) {
 308                             throw e;
 309                         }
 310                         argiter.shift();
 311                     }
 312                 }
 313                 if (argiter.length == 1) {
 314                     // optimize last element
 315                     var arg = argiter.shift();
 316                     this.next = m.bind("next", arg);
 317                     return this.next();
 318                 }
 319                 throw self.StopIteration;
 320             }
 321         };
 322     },
 323
 324     /** @id MochiKit.Iter.takewhile */
 325     takewhile: function (pred, seq) {
 326         var self = MochiKit.Iter;
 327         seq = self.iter(seq);
 328         return {
 329             repr: function () { return "takewhile(...)"; },
 330             toString: MochiKit.Base.forwardCall("repr"),
 331             next: function () {
 332                 var rval = seq.next();
 333                 if (!pred(rval)) {
 334                     this.next = function () {
 335                         throw self.StopIteration;
 336                     };
 337                     this.next();
 338                 }
 339                 return rval;
 340             }
 341         };
 342     },
 343
 344     /** @id MochiKit.Iter.dropwhile */
 345     dropwhile: function (pred, seq) {
 346         seq = MochiKit.Iter.iter(seq);
 347         var m = MochiKit.Base;
 348         var bind = m.bind;
 349         return {
 350             "repr": function () { return "dropwhile(...)"; },
 351             "toString": m.forwardCall("repr"),
 352             "next": function () {
 353                 while (true) {
 354                     var rval = seq.next();
 355                     if (!pred(rval)) {
 356                         break;
 357                     }
 358                 }
 359                 this.next = bind("next", seq);
 360                 return rval;
 361             }
 362         };
 363     },
 364
 365     _tee: function (ident, sync, iterable) {
 366         sync.pos[ident] = -1;
 367         var m = MochiKit.Base;
 368         var listMin = m.listMin;
 369         return {
 370             repr: function () { return "tee(" + ident + ", ...)"; },
 371             toString: m.forwardCall("repr"),
 372             next: function () {
 373                 var rval;
 374                 var i = sync.pos[ident];
 375
 376                 if (i == sync.max) {
 377                     rval = iterable.next();
 378                     sync.deque.push(rval);
 379                     sync.max += 1;
 380                     sync.pos[ident] += 1;
 381                 } else {
 382                     rval = sync.deque[i - sync.min];
 383                     sync.pos[ident] += 1;
 384                     if (i == sync.min && listMin(sync.pos) != sync.min) {
 385                         sync.min += 1;
 386                         sync.deque.shift();
 387                     }
 388                 }
 389                 return rval;
 390             }
 391         };
 392     },
 393
 394     /** @id MochiKit.Iter.tee */
 395     tee: function (iterable, n/* = 2 */) {
 396         var rval = [];
 397         var sync = {
 398             "pos": [],
 399             "deque": [],
 400             "max": -1,
 401             "min": -1
 402         };
 403         if (arguments.length == 1 || typeof(n) == "undefined" || n === null) {
 404             n = 2;
 405         }
 406         var self = MochiKit.Iter;
 407         iterable = self.iter(iterable);
 408         var _tee = self._tee;
 409         for (var i = 0; i < n; i++) {
 410             rval.push(_tee(i, sync, iterable));
 411         }
 412         return rval;
 413     },
 414
 415     /** @id MochiKit.Iter.list */
 416     list: function (iterable) {
 417         // Fast-path for Array and Array-like
 418         var rval;
 419         if (iterable instanceof Array) {
 420             return iterable.slice();
 421         }
 422         // this is necessary to avoid a Safari crash
 423         if (typeof(iterable) == "function" &&
 424                 !(iterable instanceof Function) &&
 425                 typeof(iterable.length) == 'number') {
 426             rval = [];
 427             for (var i = 0; i < iterable.length; i++) {
 428                 rval.push(iterable[i]);
 429             }
 430             return rval;
 431         }
 432
 433         var self = MochiKit.Iter;
 434         iterable = self.iter(iterable);
 435         var rval = [];
 436         try {
 437             while (true) {
 438                 rval.push(iterable.next());
 439             }
 440         } catch (e) {
 441             if (e != self.StopIteration) {
 442                 throw e;
 443             }
 444             return rval;
 445         }
 446         // mozilla warnings aren't too bright
 447         return undefined;
 448     },
 449
 450
 451     /** @id MochiKit.Iter.reduce */
 452     reduce: function (fn, iterable, /* optional */initial) {
 453         var i = 0;
 454         var x = initial;
 455         var self = MochiKit.Iter;
 456         iterable = self.iter(iterable);
 457         if (arguments.length < 3) {
 458             try {
 459                 x = iterable.next();
 460             } catch (e) {
 461                 if (e == self.StopIteration) {
 462                     e = new TypeError("reduce() of empty sequence with no initial value");
 463                 }
 464                 throw e;
 465             }
 466             i++;
 467         }
 468         try {
 469             while (true) {
 470                 x = fn(x, iterable.next());
 471             }
 472         } catch (e) {
 473             if (e != self.StopIteration) {
 474                 throw e;
 475             }
 476         }
 477         return x;
 478     },
 479
 480     /** @id MochiKit.Iter.range */
 481     range: function (/* [start,] stop[, step] */) {
 482         var start = 0;
 483         var stop = 0;
 484         var step = 1;
 485         if (arguments.length == 1) {
 486             stop = arguments[0];
 487         } else if (arguments.length == 2) {
 488             start = arguments[0];
 489             stop = arguments[1];
 490         } else if (arguments.length == 3) {
 491             start = arguments[0];
 492             stop = arguments[1];
 493             step = arguments[2];
 494         } else {
 495             throw new TypeError("range() takes 1, 2, or 3 arguments!");
 496         }
 497         if (step === 0) {
 498             throw new TypeError("range() step must not be 0");
 499         }
 500         return {
 501             next: function () {
 502                 if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
 503                     throw MochiKit.Iter.StopIteration;
 504                 }
 505                 var rval = start;
 506                 start += step;
 507                 return rval;
 508             },
 509             repr: function () {
 510                 return "range(" + [start, stop, step].join(", ") + ")";
 511             },
 512             toString: MochiKit.Base.forwardCall("repr")
 513         };
 514     },
 515
 516     /** @id MochiKit.Iter.sum */
 517     sum: function (iterable, start/* = 0 */) {
 518         if (typeof(start) == "undefined" || start === null) {
 519             start = 0;
 520         }
 521         var x = start;
 522         var self = MochiKit.Iter;
 523         iterable = self.iter(iterable);
 524         try {
 525             while (true) {
 526                 x += iterable.next();
 527             }
 528         } catch (e) {
 529             if (e != self.StopIteration) {
 530                 throw e;
 531             }
 532         }
 533         return x;
 534     },
 535
 536     /** @id MochiKit.Iter.exhaust */
 537     exhaust: function (iterable) {
 538         var self = MochiKit.Iter;
 539         iterable = self.iter(iterable);
 540         try {
 541             while (true) {
 542                 iterable.next();
 543             }
 544         } catch (e) {
 545             if (e != self.StopIteration) {
 546                 throw e;
 547             }
 548         }
 549     },
 550
 551     /** @id MochiKit.Iter.forEach */
 552     forEach: function (iterable, func, /* optional */self) {
 553         var m = MochiKit.Base;
 554         if (arguments.length > 2) {
 555             func = m.bind(func, self);
 556         }
 557         // fast path for array
 558         if (m.isArrayLike(iterable)) {
 559             try {
 560                 for (var i = 0; i < iterable.length; i++) {
 561                     func(iterable[i]);
 562                 }
 563             } catch (e) {
 564                 if (e != MochiKit.Iter.StopIteration) {
 565                     throw e;
 566                 }
 567             }
 568         } else {
 569             self = MochiKit.Iter;
 570             self.exhaust(self.imap(func, iterable));
 571         }
 572     },
 573
 574     /** @id MochiKit.Iter.every */
 575     every: function (iterable, func) {
 576         var self = MochiKit.Iter;
 577         try {
 578             self.ifilterfalse(func, iterable).next();
 579             return false;
 580         } catch (e) {
 581             if (e != self.StopIteration) {
 582                 throw e;
 583             }
 584             return true;
 585         }
 586     },
 587
 588     /** @id MochiKit.Iter.sorted */
 589     sorted: function (iterable, /* optional */cmp) {
 590         var rval = MochiKit.Iter.list(iterable);
 591         if (arguments.length == 1) {
 592             cmp = MochiKit.Base.compare;
 593         }
 594         rval.sort(cmp);
 595         return rval;
 596     },
 597
 598     /** @id MochiKit.Iter.reversed */
 599     reversed: function (iterable) {
 600         var rval = MochiKit.Iter.list(iterable);
 601         rval.reverse();
 602         return rval;
 603     },
 604
 605     /** @id MochiKit.Iter.some */
 606     some: function (iterable, func) {
 607         var self = MochiKit.Iter;
 608         try {
 609             self.ifilter(func, iterable).next();
 610             return true;
 611         } catch (e) {
 612             if (e != self.StopIteration) {
 613                 throw e;
 614             }
 615             return false;
 616         }
 617     },
 618
 619     /** @id MochiKit.Iter.iextend */
 620     iextend: function (lst, iterable) {
 621         if (MochiKit.Base.isArrayLike(iterable)) {
 622             // fast-path for array-like
 623             for (var i = 0; i < iterable.length; i++) {
 624                 lst.push(iterable[i]);
 625             }
 626         } else {
 627             var self = MochiKit.Iter;
 628             iterable = self.iter(iterable);
 629             try {
 630                 while (true) {
 631                     lst.push(iterable.next());
 632                 }
 633             } catch (e) {
 634                 if (e != self.StopIteration) {
 635                     throw e;
 636                 }
 637             }
 638         }
 639         return lst;
 640     },
 641
 642     /** @id MochiKit.Iter.groupby */
 643     groupby: function(iterable, /* optional */ keyfunc) {
 644         var m = MochiKit.Base;
 645         var self = MochiKit.Iter;
 646         if (arguments.length < 2) {
 647             keyfunc = m.operator.identity;
 648         }
 649         iterable = self.iter(iterable);
 650
 651         // shared
 652         var pk = undefined;
 653         var k = undefined;
 654         var v;
 655
 656         function fetch() {
 657             v = iterable.next();
 658             k = keyfunc(v);
 659         };
 660
 661         function eat() {
 662             var ret = v;
 663             v = undefined;
 664             return ret;
 665         };
 666
 667         var first = true;
 668         var compare = m.compare;
 669         return {
 670             repr: function () { return "groupby(...)"; },
 671             next: function() {
 672                 // iterator-next
 673
 674                 // iterate until meet next group
 675                 while (compare(k, pk) === 0) {
 676                     fetch();
 677                     if (first) {
 678                         first = false;
 679                         break;
 680                     }
 681                 }
 682                 pk = k;
 683                 return [k, {
 684                     next: function() {
 685                         // subiterator-next
 686                         if (v == undefined) { // Is there something to eat?
 687                             fetch();
 688                         }
 689                         if (compare(k, pk) !== 0) {
 690                             throw self.StopIteration;
 691                         }
 692                         return eat();
 693                     }
 694                 }];
 695             }
 696         };
 697     },
 698
 699     /** @id MochiKit.Iter.groupby_as_array */
 700     groupby_as_array: function (iterable, /* optional */ keyfunc) {
 701         var m = MochiKit.Base;
 702         var self = MochiKit.Iter;
 703         if (arguments.length < 2) {
 704             keyfunc = m.operator.identity;
 705         }
 706
 707         iterable = self.iter(iterable);
 708         var result = [];
 709         var first = true;
 710         var prev_key;
 711         var compare = m.compare;
 712         while (true) {
 713             try {
 714                 var value = iterable.next();
 715                 var key = keyfunc(value);
 716             } catch (e) {
 717                 if (e == self.StopIteration) {
 718                     break;
 719                 }
 720                 throw e;
 721             }
 722             if (first || compare(key, prev_key) !== 0) {
 723                 var values = [];
 724                 result.push([key, values]);
 725             }
 726             values.push(value);
 727             first = false;
 728             prev_key = key;
 729         }
 730         return result;
 731     },
 732
 733     /** @id MochiKit.Iter.arrayLikeIter */
 734     arrayLikeIter: function (iterable) {
 735         var i = 0;
 736         return {
 737             repr: function () { return "arrayLikeIter(...)"; },
 738             toString: MochiKit.Base.forwardCall("repr"),
 739             next: function () {
 740                 if (i >= iterable.length) {
 741                     throw MochiKit.Iter.StopIteration;
 742                 }
 743                 return iterable[i++];
 744             }
 745         };
 746     },
 747
 748     /** @id MochiKit.Iter.hasIterateNext */
 749     hasIterateNext: function (iterable) {
 750         return (iterable && typeof(iterable.iterateNext) == "function");
 751     },
 752
 753     /** @id MochiKit.Iter.iterateNextIter */
 754     iterateNextIter: function (iterable) {
 755         return {
 756             repr: function () { return "iterateNextIter(...)"; },
 757             toString: MochiKit.Base.forwardCall("repr"),
 758             next: function () {
 759                 var rval = iterable.iterateNext();
 760                 if (rval === null || rval === undefined) {
 761                     throw MochiKit.Iter.StopIteration;
 762                 }
 763                 return rval;
 764             }
 765         };
 766     }
 767 });
 768
 769
 770 MochiKit.Iter.EXPORT_OK = [
 771     "iteratorRegistry",
 772     "arrayLikeIter",
 773     "hasIterateNext",
 774     "iterateNextIter",
 775 ];
 776
 777 MochiKit.Iter.EXPORT = [
 778     "StopIteration",
 779     "registerIteratorFactory",
 780     "iter",
 781     "count",
 782     "cycle",
 783     "repeat",
 784     "next",
 785     "izip",
 786     "ifilter",
 787     "ifilterfalse",
 788     "islice",
 789     "imap",
 790     "applymap",
 791     "chain",
 792     "takewhile",
 793     "dropwhile",
 794     "tee",
 795     "list",
 796     "reduce",
 797     "range",
 798     "sum",
 799     "exhaust",
 800     "forEach",
 801     "every",
 802     "sorted",
 803     "reversed",
 804     "some",
 805     "iextend",
 806     "groupby",
 807     "groupby_as_array"
 808 ];
 809
 810 MochiKit.Iter.__new__ = function () {
 811     var m = MochiKit.Base;
 812     // Re-use StopIteration if exists (e.g. SpiderMonkey)
 813     if (typeof(StopIteration) != "undefined") {
 814         this.StopIteration = StopIteration;
 815     } else {
 816         /** @id MochiKit.Iter.StopIteration */
 817         this.StopIteration = new m.NamedError("StopIteration");
 818     }
 819     this.iteratorRegistry = new m.AdapterRegistry();
 820     // Register the iterator factory for arrays
 821     this.registerIteratorFactory(
 822         "arrayLike",
 823         m.isArrayLike,
 824         this.arrayLikeIter
 825     );
 826
 827     this.registerIteratorFactory(
 828         "iterateNext",
 829         this.hasIterateNext,
 830         this.iterateNextIter
 831     );
 832
 833     this.EXPORT_TAGS = {
 834         ":common": this.EXPORT,
 835         ":all": m.concat(this.EXPORT, this.EXPORT_OK)
 836     };
 837
 838     m.nameFunctions(this);
 839
 840 };
 841
 842 MochiKit.Iter.__new__();
 843
 844 //
 845 // XXX: Internet Explorer blows
 846 //
 847 if (MochiKit.__export__) {
 848     reduce = MochiKit.Iter.reduce;
 849 }
 850
 851 MochiKit.Base._exportSymbols(this, MochiKit.Iter);